Tcl Library Source Code

Check-in Differences
Login
Bounty program for improvements to Tcl and certain Tcl packages.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Difference From trunk To mjanssen-changes

2021-03-08
14:29
Fix inconsistent profiler pkgIndex.tcl Leaf check-in: f9ee8b1b48 user: mpcjanssen tags: trunk
2021-03-07
14:21
Add various [package require] statements to expose the proper requirements check-in: 20bad8fa14 user: arjenmarkus tags: trunk
2017-03-30
20:01
Fix bug in tcc4tcl md5 implementation Leaf check-in: e255c39fbf user: Mark tags: mjanssen-changes
15:33
Merged tcc4tcl changes check-in: dfe89741cf user: Mark tags: mjanssen-changes

Deleted .fossil-settings/binary-glob.

1
2
3
4
5
*.tiff *.png *.jpg *.JPG *.JPG.thumb
*.fossil *.sqlite *.ckout *.global
*.torrent
*.pdf
*/yencode.test.data */yencode.test.out
<
<
<
<
<










Deleted .fossil-settings/crlf-glob.

1
2
3
modules/pt/tests/data/ok/peg_serial-canonical/3_peg_itself
modules/fumagic/fumagic.testsupport
*.bat
<
<
<






Deleted .fossil-settings/encoding-glob.

1
2
3
4
modules/mime/mime.test
modules/base64/yencode.test.out
modules/fileutil/test-assets/pdf4tcl_01.pdf
modules/png/test-assets/xlfn0g04.png
<
<
<
<








Deleted .fossil-settings/ignore-glob.

1
2
3
4
5
M
MSG*
X.*
_work
modules/tcllibc
<
<
<
<
<










Changes to .github/CONTRIBUTING.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello. __Attention please__

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where Tcllib development takes place.

We are __not tracking issues entered here__. With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl-lang.org/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl-lang.org/tcllib/reportlist)
instead.

Thank you for your consideration.

|



|

|



|

|



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello.

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where development takes place.

We are not tracking issues entered here.  With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl.tk/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl.tk/tcllib/reportlist)
instead.

Thank you for your consideration.

Changes to .github/ISSUE_TEMPLATE.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello. __Attention please__

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where Tcllib development takes place.

We are __not tracking issues entered here__. With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl-lang.org/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl-lang.org/tcllib/reportlist)
instead.

Thank you for your consideration.

|



|

|



|

|



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello.

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where development takes place.

We are not tracking issues entered here.  With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl.tk/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl.tk/tcllib/reportlist)
instead.

Thank you for your consideration.

Changes to .github/PULL_REQUEST_TEMPLATE.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello. __Attention please__

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where Tcllib development takes place.

We are __not tracking issues entered here__. With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl-lang.org/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl-lang.org/tcllib/reportlist)
instead.

Thank you for your consideration.

|



|

|



|

|



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Hello.

You are currently using the github __mirror__ of the Tcllib sources.

This is __not__ the location where development takes place.

We are not tracking issues entered here.  With the exception of the
maintainer of the mirroring setup nobody will even see such issues.

Please go to the
[official location of the sources](https://core.tcl.tk/tcllib)
and enter your ticket into the
[official ticket tracker](https://core.tcl.tk/tcllib/reportlist)
instead.

Thank you for your consideration.

Changes to DESCRIPTION.txt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Identifier: tcllib
Title:  Tcl Standard Library
Description: This package is intended to be a collection of
    Tcl packages that provide utility functions useful to a
    large collection of Tcl programmers.
Rights: BSD
Version: 1.20
URL: http://core.tcl.tk/tcllib
Architecture: tcl
Contributor:  <jeffh at activestate dot com>
Contributor: Aaron Faupell <afaupell at users dot sourceforge dot net>
Contributor: Andreas Kupries <andreas_kupries at users dot sourceforge dot net>
Contributor: Arjen Markus <arjenmarkus at users dot sourceforge dot net>
Contributor: Benjamin Riefenstahl <b dot riefenstahl at turtle-trading dot net>
Contributor: Bob Techentin <techentin at users dot sourceforge dot net>
Contributor: Brent Welch <welch at scriptics dot com>
Contributor: Brett Schwarz <schwarzkopf at users dot sourceforge dot net>
Contributor: Colin McCormack <coldstore at users dot sourceforge dot net>
Contributor: Dan Kuchler <kuchler at ajubasolutions dot com>
Contributor: David N. Welton <davidw at dedasys dot com>
Contributor: Don Porter <dgp at users dot sourceforge dot net>
Contributor: Donal K. Fellows <fellowsd at cs dot man dot ac dot uk>
Contributor: Elchonon Edelson <eee at users dot sourceforge dot net>
Contributor: Emmanuel Frecon <efrecon at gmail dot com>
Contributor: Eric Melski <ericm at ajubasolutions dot com>
Contributor: Gerald Lester <gwlester at users dot sourceforge dot net>
Contributor: Gerhard Reithofer <gerhard dot rithofer at tech-edv dot co dot at>
Contributor: Harald Oehlmann <oehhar at users dot sourceforge dot net>
Contributor: Jeff Hobbs <jeffh at ActiveState dot com>
Contributor: Joe English <jenglish at users dot sourceforge dot net>
Contributor: Johannes-Heinrich Vogeler <vogeler at users dot sourceforge dot net>
Contributor: KATO Kanryu <kanryu6 at users dot sourceforge dot net>
Contributor: Kevin B, Kenny <kennykb at acm dot org>
Contributor: Kevin B. Kenny <kennykb at acm dot org>
Contributor: Kevin Kenny <kennykb at users dot sourceforge dot net>






|




















<







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

28
29
30
31
32
33
34
Identifier: tcllib
Title:  Tcl Standard Library
Description: This package is intended to be a collection of
    Tcl packages that provide utility functions useful to a
    large collection of Tcl programmers.
Rights: BSD
Version: 1.18
URL: http://core.tcl.tk/tcllib
Architecture: tcl
Contributor:  <jeffh at activestate dot com>
Contributor: Aaron Faupell <afaupell at users dot sourceforge dot net>
Contributor: Andreas Kupries <andreas_kupries at users dot sourceforge dot net>
Contributor: Arjen Markus <arjenmarkus at users dot sourceforge dot net>
Contributor: Benjamin Riefenstahl <b dot riefenstahl at turtle-trading dot net>
Contributor: Bob Techentin <techentin at users dot sourceforge dot net>
Contributor: Brent Welch <welch at scriptics dot com>
Contributor: Brett Schwarz <schwarzkopf at users dot sourceforge dot net>
Contributor: Colin McCormack <coldstore at users dot sourceforge dot net>
Contributor: Dan Kuchler <kuchler at ajubasolutions dot com>
Contributor: David N. Welton <davidw at dedasys dot com>
Contributor: Don Porter <dgp at users dot sourceforge dot net>
Contributor: Donal K. Fellows <fellowsd at cs dot man dot ac dot uk>
Contributor: Elchonon Edelson <eee at users dot sourceforge dot net>
Contributor: Emmanuel Frecon <efrecon at gmail dot com>
Contributor: Eric Melski <ericm at ajubasolutions dot com>
Contributor: Gerald Lester <gwlester at users dot sourceforge dot net>
Contributor: Gerhard Reithofer <gerhard dot rithofer at tech-edv dot co dot at>

Contributor: Jeff Hobbs <jeffh at ActiveState dot com>
Contributor: Joe English <jenglish at users dot sourceforge dot net>
Contributor: Johannes-Heinrich Vogeler <vogeler at users dot sourceforge dot net>
Contributor: KATO Kanryu <kanryu6 at users dot sourceforge dot net>
Contributor: Kevin B, Kenny <kennykb at acm dot org>
Contributor: Kevin B. Kenny <kennykb at acm dot org>
Contributor: Kevin Kenny <kennykb at users dot sourceforge dot net>

Added INSTALL.txt.



























































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
How to install Tcllib
=====================

Introduction
------------

The tcllib distribution, whether a snapshot directly from CVS, or
officially released, offers a single method for installing tcllib,
based on Tcl itself.

This is based on the assumption that for tcllib to be of use Tcl has
to be present, and therefore can be used.

This single method however can be used in a variety of ways.

0	For an unwrapped (= directory) distribution or CVS snapshot

	a.	either call the application 'installer.tcl' directly,
	b	or use

			% configure ; make install

		The latter is provided for people which are used to
		this method and more comfortable with it. In end this
		boils down into a call of 'installer.tcl' too.

1.	A starpack distribution (window-only) is a self-extracting
	installer which internally uses the aforementioned installer.

2.	A starkit distribution is very much like a starpack, but
	required an external interpreyter to run. This can be any tcl
	interpreter which has all the packages to support starkits
	(tclvfs, memchan, trf).

3.	A distribution in a tarball has to be unpacked first, then any
	of the methods described in (0) can be used.


Usage of the installer
----------------------

The installer selects automatically either a gui based mode, or a
command line based mode. If the package Tk is present and can be
loaded, then the GUI mode is entered, else the system falls back to
the command line.

Note that it is possible to specify options on the command line even
if the installer ultimatively selects a gui mode. In that case the
hardwired defaults and the options determine the data presented to the
user for editing.

Command line help can be asked for by using the option -help when
running the installer (3) or the distribution itself in the case of
(1) or (2).

The installer will select a number of defaults for the locations of
packages, examples, and documentation, and also the format of the
documentation. The user can overide these defaults in the GUI, or by
specifying additional options.

The defaults depend on the platform detected (unix/windows) and the
executable used to run the installer. In the case of a starpack
distribution (1) this means that _no defaults_ are possible for the
various locations as the executable is part of the distribution and
has no knowledge of its environment.

In all other cases the intepreter executable is outside of the
distribution, which means that its location can be used to determine
sensible defaults.

Notes
-----

The installer will overwrite an existing installation of tcllib 1.6
without asking back after the initial confirmation is given. And if
the user chooses the same directory as for tcllib 1.4, or 1.3, etc.
then the installer will overwrite that too.

Added README.

































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
RCS: @(#) $Id: README,v 1.9 2007/08/30 17:24:13 andreas_kupries Exp $

Welcome to the Tcllib, the Tcl Standard Library.  This package is
intended to be a collection of Tcl packages that provide utility
functions useful to a large collection of Tcl programmers.

The home web site for this code is http://core.tcl.tk/tcllib/ .
At this web site, you will find mailing lists, web forums, databases
for bug reports and feature requests, the CVS repository (browsable on
the web, or read-only accessible via CVS ), and more.

The structure of the tcllib source hierarchy is:

tcllib
 +- modules
     +- <module1>
     +- <module2>
     +- ...


The install hierarchy is:

.../lib/tcllib
        +- <module1>
        +- <module2>
        +- ...

There are some base requirements that a module must meet before it
will be added to tcllib:

* the module must be a proper Tcl package
* the module must use a namespace for its commands and variables
* the name of the package must be the same as the name of the
  namespace
* the module must reside in a subdirectory of the modules directory in
  the source hierarchy, and that subdirectory must have the same name
  as the package and namespace
* the module must be released under the BSD License, the terms of
  which can be found in the toplevel tcllib source directory in the file
  license.terms
* the module should have both documentation ([*]) and a test suite
  (in the form of a group of *.test files in the module directory).

  [*] Possible forms: doctools, TMML/XML, nroff (man), or HTML.
      The first format is the most preferred as it can be processed with
      tools provided by tcllib itself (See module doctools). The first
      two are preferred in general as they are semantic markup and thus
      easier to convert into other formats.

* the module must have either documentation or a test suite.  It can
  not have neither.
* the module should adhere to Tcl coding standards

When adding a module to tcllib, be sure to add it to the files listed below.

* installed_modules.tcl

  contains a table listing all modules to be installed, modules
  excluded, and names the actions to be taken during installation
  of each module. Add a line to this table naming your module and
  its actions.

  Three actions have to be specified, for the package itself, its
  documentation, and the examples demonstrating it.

  The _null action can be used everywhere and signals that there is
  nothing to do. Although it is possible to use it for the package
  action it does make no sense there, as that means that no package
  code is installed.

  Other package actions are _tcl, _tci, and _text. The first causes
  the installer to copy all .tcl files from the source directory for
  the module into the appropriate module directory. _tci does all that
  and also expects a tclIndex file to copy. _tex is like _tcl, however
  it also copies all .tex files found in the source directory for the
  module.

  There is currently only one true documentation action. This action
  is _doc. It converts all documentation in doctools format into the
  format chosen by the user for installation and copies the result
  into the appropriate directory.

  There is currently one true action for examples, _exa. It copies all
  files in the source directory for examples into the directory chosen
  by the user as destination for examples.

Each module source directory should have no subdirectories (other than
the CVS directory), and should contain the following files:

* source code		*.tcl
* package index		pkgIndex.tcl
* tests			*.test
* documentation		*.man, *.n, *.xml

If you do not follow this directory structure, the tcllib Makefile
will fail to locate the files from the new module.

Added README.developer.

























































































































































































































































































































































































































































































































































































































































































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
RCS: @(#) $Id: README.developer,v 1.6 2009/06/02 22:49:55 andreas_kupries Exp $

Welcome to the tcllib, the Tcl Standard Library.
================================================

Introduction
------------

This README is intended to be a guide to the tools available to a

	Developer

working on Tcllib to help him with his tasks, i.e. making the tasks easier
to perform. It is our hope that this will improve the quality of even
non-released revisions of Tcllib, and make the work of the release
manager easier as well.

Audience
--------

The intended audience are, first and foremost, developers beginning to
work on Tcllib. To an experienced developer this document will be less
of a guide and more of a reference. Anybody else interested in working
on Tcllib is invited as well.


Directory hierarchy and file basics
------------------------------------

The main directories under the tcllib top directory are

	modules/
	examples/
and	apps/

Each directory FOO under modules/ represents one package, sometimes
more. In the case of the latter the packages are usually related in
some way. Examples are the base64, math, and struct modules, with
loose (base64) to strong (math) relations between the packages.

Examples associated with a module FOO, if there are any, are placed
into the directory

	examples/FOO

Any type of distributable application can be found under apps/,
together with their documentation, if any. Note that the apps/
directory is currently not split into sub-directories.

Regarding the files in Tcllib, the most common types found are

	.tcl	Tcl code for a package.

	.man	Documentation for a package, in doctools format.

	.test	Test suite for a package, or part of. Based on tcltest.

	.bench	Performance benchmarks for a package, or part of.
		Based on modules/bench

	.pcx	Syntax rules for TclDevKit's tclchecker. Using these
		rules allows tclchecker to check the use of commands
		of a Tcllib package X without having to scan the
		implementation of X, i.e. its .tcl files.


Adding a new module
-------------------

Assuming that FOO is the name of the new module, and T is the toplevel
directory of the Tcllib sources

(1)	Create the directory T/modules/FOO and put all the files of
	the module into it. Note:

	* The file 'pkgIndex.tcl' is required.

	* Implementation files should have the extension '.tcl',
	  naturally.

	* If available, documentation should be in doctools format,
          and the files should have the extension '.man' for SAK to
          recognize them.

	* If available the testsuite(s) should use 'tcltest' and the
	  general format as used by the other modules in Tcllib
	  (declaration of minimally needed Tcl, tcltest, supporting
	  packages, etc.). The file(s) should have the extension
	  '.test' for SAK to recognize them.

	  Note that an empty testsuite, or a testsuite which does not
	  perform any tests is less than useful and will not be
	  accepted.

	* If available the benchmark(s) should use 'bench' and the
          general format as used by the other modules in Tcllib. The
          file(s) should have the extension '.bench' for SAK to
          recognize them.

	* Other files can be named and placed as the module sees fit.

(2)	If the new module has an example application A which is
	polished enough for general use, put this application into the
	file "T/apps/A.tcl", and its documentation into the file
	"T/apps/A.man". While documentation for the application is
	optional, it is preferred.

	For examples which are not full-fledged applications, a
	skeleton, or not really polished for use, etc., create the
	directory T/examples/FOO/ and put them there.

	A key difference is what happens to them on installation, and
	what the target audience is.

	The examples are for developers using packages in Tcllib,
	whereas the applications are also for users of Tcllib which do
	not have an interest in developing for and with it. As such,
	they are installed as regular commands, accessible through the
	PATH, and example files are not installed.

(3)	To make Tcllib's installer aware of FOO, edit the file

		T/support/installation/modules.tcl

	Add a line 'Module FOO $impaction $docaction $exaction'. The
	various actions describe to the installer how to install the
	implementation files, the documentation, and the examples.

	Add a line 'Application A' for any application A which was
	added to T/apps for FOO.

	The following actions are available:

	Implementation

		_tcl - Copy all .tcl files in T/modules/FOO into the installation.
		_tcr - See above, does it for .tcl files in subdirectories as well.
		_tci - _tcl + Copying of a tclIndex - special to modules 'math', 'control'.
		_msg - _tcl + Copying of subdir 'msgs' - special to modules 'dns', 'log'.
		_doc - _tcl + Copying of subdir 'mpformats' - special to module 'doctools'.
		_tex - _tcl + Copying of .tex files - special to module 'textutil'.

		The _null action, see below, is available in principle
		too, but a module without implementation does not make
		sense.

	Documentation

		_null - Module has no documentation, do nothing.
		_man  - Process the .man files in T/modules/FOO and
			install the results (nroff and/or HTML) in the
			proper location, as given to the installer.

	Examples

		_null - Module has no examples, do nothing
		_exa  - Copy the directory T/examples/FOO
			(recursively) to the install location for
			examples.


Testing modules
---------------

To run the testsuite of a module FOO in tcllib use the 'test run'
argument of sak.tcl, like so:

	% pwd
	/the/tcllib/toplevel/directory

	% ./sak.tcl test run FOO
or	% ./sak.tcl test run modules/FOO

To run the testsuites of all modules either invoke 'test run' without a
module name, or use 'make test'. The latter assumes that configure was
run for Tcllib before, i.e.:

	% ./sak.tcl test run
or	% ./sak.tcl test run
	% make test

In all of the above cases the result will be a combination of progress
display and testsuite log, showing for each module the tests that pass
or failed and how many of each in a summary at the end.

To get a detailed log, it is necessary to invoke 'test run' with
additional options.

First example:
	% ./sak.tcl test run -l LOG FOO

This shows the same short log on the terminal, and writes a detailed
log to the file LOG.log, and excerpts to other files (LOG.summary,
LOG.failures, etc.).

Second example:
	% ./sak.tcl test run -v FOO
	% make test > LOG

This writes the detailed log to stdout, or to the file LOG, instead of
the short log. In all cases, the detailed log contains a list of all
test cases executed, which failed, and how they failed (expected
versus actual results).

Note:
The commands
	% make test
and	% make test > LOG

are able to generate different output (short vs long log) because the
Makefile target contains code which detects that stdout has been
redirected to a file and acts accordingly.

Non-developers should reports problems in Tcllib's bug tracker.
Information about its location and the relevant category can be found
in the section 'BUGS, IDEAS, FEEDBACK' of the manpage of the module
and/or package.

Module documentation
--------------------

The main format used for the documentation of packages in Tcllib is
'doctools', the support packages of which are part of Tcllib, see the
module 'doctools'.

To convert this documentation to HTML or nroff manpages, or some other
format use the 'doc' argument of sak.tcl, like so:

	% pwd
	/the/tcllib/toplevel/directory

	% ./sak.tcl doc html FOO
or	% ./sak.tcl doc html modules/FOO

The result of the conversion can be found in the newly-created 'doc'
directory in the current working directory.

The set of formats the documentation can be converted into can be
queried via

	% ./sak.tcl help doc


To convert the documentation of all modules either invoke 'test run'
without a module name, or use 'make html-doc', etc.. The latter
assumes that configure was run for Tcllib before, i.e.:

	% ./sak.tcl doc html
	% make html-doc

Note the special format 'validate'. Using this format does not convert
the documentation to anything (and the sub-directory 'doc' will not be
created), it just checks that the documentation is syntactically
correct. I.e.

	% ./sak.tcldoc validate modules/FOO
	% ./sak.tcldoc validate


Validating modules
------------------

Running the testsuite of a module, or checking the syntax of its
documentation (see the previous sections) are two forms of validation.

The 'validate' command of sak.tcl provides a few more. The online
documentation of this command is available via

	% ./sak.tcl help validate

The validated parts are man pages, testsuites, version information,
and syntax. The latter only if various static syntax checkers are
available on the PATH, like TclDevKit's tclchecker.

Note that testsuite validation is not the execution of the testsuites,
only if a package has a testsuite or not.

It is strongly recommended to validate a module before committing any
type of change made to it.

It is recommended to validate all modules before committing any type
of change made to one of them. We have package inter-dependencies
between packages in Tcllib, thus changing one package may break
others, and just validating the changed package will not catch such
problems.


Writing Tests
-------------

While a previous section talked about running the testsuite for a
module and the packages therein this has no meaning if the module in
question has no testsuites at all.

This section gives a very basic overview on methodologies for writing
tests and testsuites.

First there are "drudgery" tests. Written to check absolutely basic
assumptions which should never fail.

Example:

	For a command FOO taking two arguments, three tests calling it
	with zero, one, and three arguments. The basic checks that the
	command fails if it has not enough arguments, or too many.

After that come the tests checking things based on our knowledge of
the command, about its properties and assumptions. Some examples based
on the graph operations added during Google's Summer of Code 2009.

**	The BellmanFord command in struct::graph::ops takes a
	_startnode_ as argument, and this node should be a node of the
	graph. equals one test case checking the behavior when the
	specified node is not a node a graph.

	This often gives rise to code in the implementation which
	explicitly checks the assumption and throws a nice error.
	Instead of letting the algorithm fails later in some weird
	non-deterministic way.

	Such checks cannot be done always. The graph argument for
	example is just a command in itself, and while we expect it to
	exhibit a certain interface, i.e. set of sub-commands aka
	methods, we cannot check that it has them, except by actually
	trying to use them. That is done by the algorithm anyway, so
	an explicit check is just overhead we can get by without.

**	IIRC one of the distinguishing characteristic of either
	BellmanFord and/or Johnson is that they are able to handle
	negative weights. Whereas Dijkstra requires positive weights.

	This induces (at least) three testcases ... Graph with all
	positive weights, all negative, and a mix of positive and
	negative weights.

	Thinking further does the algorithm handle the weight '0' as
	well ? Another test case, or several, if we mix zero with
	positive and negative weights.

**	The two algorithms we are currently thinking about are about
	distances between nodes, and distance can be 'Inf'inity,
	i.e. nodes may not be connected. This means that good test
	cases are

	(1)	Strongly connected graph
	(2)	Connected graph
	(3)	Disconnected graph.

	At the extremes of (1) and (3) we have the fully connected
	graphs and graphs without edges, only nodes, i.e. completely
	disconnected.

**	IIRC both of the algorithms take weighted arcs, and fill in a
	default if arcs are left unweighted in the input graph.

	This also induces three test cases:

	(1)	Graph will all arcs with explicit weights.
	(2)	Graph without weights at all.
	(3)	Graph with mixture of weighted and unweighted graphs.


What was described above via examples is called 'black-box' testing.
Test cases are designed and written based on our knowledge of the
properties of the algorithm and its inputs, without referencing a
particular implementation.

Going further, a complement to 'black-box' testing is 'white-box'. For
this we know the implementation of the algorithm, we look at it and
design our tests cases so that they force the code through all
possible paths in the implementation. Wherever a decision is made we
have a test cases forcing a specific direction of the decision, for
all possible directions.

In practice I often hope that the black-box tests I have made are
enough to cover all the paths, obviating the need for white-box tests.

So, if you, dear reader, now believe that writing tests for an
algorithm takes at least as much time as coding the algorithm, and
often more time, then you are completely right. It does. Much more
time. See for example also http://sqlite.org/testing.html, a writeup
on how the Sqlite database engine is tested.



An interesting connection is to documentation. In one direction, the
properties you are checking with black-box testing are properties
which should be documented in the algorithm man page. And conversely,
if you have documentation of properties of an algorithm then this is a
good reference to base black-box tests on.

In practice test cases and documentation often get written together,
cross-influencing each other. And the actual writing of test cases is
a mix of black and white box, possibly influencing the implementation
while writing the tests. Like writing test for 'startnode not in input
graph' serving as reminder to put in a check for this into the code.

Changes to README.md.

1

2


3

4

5

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
# Attention




:warning: 

This repository is mirrored to [github](https://github.com/tcltk/tcllib).



We are __not tracking issues at github__.  With the exeception of the
maintainer of the mirroring setup nobody will even see issues created
at github.

Please use the
[official ticket tracker](https://core.tcl-lang.org/tcllib/reportlist)
instead.

# Welcome

Welcome to Tcllib, the Tcl Standard Library. Note that Tcllib is not a
package itself. It is a collection of (semi-independent) Tcl packages
that provide utility functions useful to a large collection of Tcl
programmers.

At our [home site](http://core.tcl-lang.org/tcllib) you will find the
official fossil repository used to manage our sources, together with
the bug tracker. This is also the main location for releases to
download from.

We have a
[secondary download location](https://sourceforge.net/projects/tcllib/files)
where the Tcllib sources were hosted in the past. SourceForge is also
where our [mailing lists](https://sourceforge.net/p/tcllib/mailman)
are (still) hosted.

Another location to find these sources at is the
[github mirror](https://github.com/tcltk/tcllib).

Please note the :warning: at the top.

# Guides To Tcllib

   * [Tcl Community - Kind Communication](embedded/www/tcllib/files/devdoc/tcl_community_communication.html)
   * [License](embedded/www/tcllib/files/devdoc/tcllib_license.html)
   * [How To Get The Sources](embedded/www/tcllib/files/devdoc/tcllib_sources.html)
   * [How To Build And Install Tcllib](embedded/www/tcllib/files/devdoc/tcllib_installer.html)
   * [The Developer's Guide](embedded/www/tcllib/files/devdoc/tcllib_devguide.html)
   * [The Release Manager's Guide](embedded/www/tcllib/files/devdoc/tcllib_releasemgr.html)
|
>

>
>
|
>
|
>

>
|
|
<


|

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
1
2
3
4
5
6
7
8
9
10
11
12
13

14
15
16
17

































Hello.

If you are reading this then you are very likely at the github
__mirror__ of the Tcllib sources.

This means that the
[official location of the sources](https://core.tcl.tk/tcllib)
is somewhere else, just follow the link.

This is also where our issue tracking is done.  We are not tracking
issues at github.  With the exeception of the maintainer of the
mirroring setup nobody will even see issues created at github.


Please use the
[official ticket tracker](https://core.tcl.tk/tcllib/reportlist)
instead.
































Added README.releasemgr.



































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
RCS: @(#) $Id: README.releasemgr,v 1.2 2009/07/10 16:33:31 andreas_kupries Exp $

Welcome to the tcllib, the Tcl Standard Library.
================================================

Introduction
------------

This README is intended to be a guide to the tools available to a

	Release manager

working on the creation of a release of Tcllib.

Audience
--------

The intended audience is the release manager of Tcllib, his deputies,
and anybody else interested in the task.

Basics
------

< Flesh this out >

	sak.tcl validate
	sak.tcl test run
	sak.tcl review
	sak.tcl readme
	sak.tcl localdoc
	sak.tcl release (change to include rpmspec+gentip55+yml)

< Tasks, and how to perform them >

  	 Making a release (candidate) branch.
	 Readying the release in the branch.
	 Make the release official, merging the branch back.

Uploading and releasing files
--------------------------------------------

(1) Create a proper fossil event for the release, via

      http://core.tcl.tk/tcllib/eventedit

    See existing events (*) for a template

    (Ad *) http://core.tcl.tk/tcllib/event/dac0ddcd2e990234143196b4dc438fe01e7b9817

(2) Update the following web locations

    (a) Home page:	http://core.tcl.tk/tcllib/home
    (b) Downloads:	http://core.tcl.tk/tcllib/wiki?name=Downloads 
    (c) Past Releases:	http://core.tcl.tk/tcllib/wiki?name=Past+Releases

    Admin access to the fossil repository required

    (d) http://www.tcl.tk/home/release.txt
    (e) http://www.tcl.tk/software/tcllib/*.tml

    ssh access to tcl.activestate.com
    aka        	  www.tcl.tk
    required.

    (f) http://wiki.tcl.tk/1246

Changes to apps/dtplite.man.

439
440
441
442
443
444
445
446
447

They are left in place, i.e. not deleted, to serve as demonstrations
of doctoc and docidx markup.

[list_end]

[vset CATEGORY doctools]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

439
440
441
442
443
444
445
446
447

They are left in place, i.e. not deleted, to serve as demonstrations
of doctoc and docidx markup.

[list_end]

[vset CATEGORY doctools]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Changes to apps/nns.man.

135
136
137
138
139
140
141
142
143
If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the name service to talk to is listening on for
requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

135
136
137
138
139
140
141
142
143
If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the name service to talk to is listening on for
requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Changes to apps/nnsd.man.

83
84
85
86
87
88
89
90
91

If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the server has to listen on for requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

83
84
85
86
87
88
89
90
91

If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the server has to listen on for requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Changes to apps/nnslog.man.

85
86
87
88
89
90
91
92
93
If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the name service to talk to is listening on for
requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

85
86
87
88
89
90
91
92
93
If this option is not specified it defaults to [const 38573]. It
specifies the TCP port the name service to talk to is listening on for
requests.

[list_end]

[vset CATEGORY nameserv]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Changes to apps/page.man.

459
460
461
462
463
464
465
466
467
[para]

The contents of both environment variables and registry entries are
interpreted as a list of paths, with the elements separated by either
colon (Unix), or semicolon (Windows).

[vset CATEGORY page]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

459
460
461
462
463
464
465
466
467
[para]

The contents of both environment variables and registry entries are
interpreted as a list of paths, with the elements separated by either
colon (Unix), or semicolon (Windows).

[vset CATEGORY page]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Changes to apps/tcldocstrip.man.

189
190
191
192
193
194
195
196
197
Preambles, when active, are written before the actual content of a
generated file. In the same manner postambles are, when active,
written after the actual content of a generated file.

[list_end]

[vset CATEGORY docstrip]
[include ../modules/common-text/feedback.inc]
[manpage_end]







|

189
190
191
192
193
194
195
196
197
Preambles, when active, are written before the actual content of a
generated file. In the same manner postambles are, when active,
written after the actual content of a generated file.

[list_end]

[vset CATEGORY docstrip]
[include ../modules/doctools2base/include/feedback.inc]
[manpage_end]

Deleted devdoc/README.developer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
RCS: @(#) $Id: README.developer,v 1.6 2009/06/02 22:49:55 andreas_kupries Exp $

Welcome to the tcllib, the Tcl Standard Library.
================================================

Introduction
------------

This README is intended to be a guide to the tools available to a

	Developer

working on Tcllib to help him with his tasks, i.e. making the tasks easier
to perform. It is our hope that this will improve the quality of even
non-released revisions of Tcllib, and make the work of the release
manager easier as well.

Audience
--------

The intended audience are, first and foremost, developers beginning to
work on Tcllib. To an experienced developer this document will be less
of a guide and more of a reference. Anybody else interested in working
on Tcllib is invited as well.


Directory hierarchy and file basics
------------------------------------

The main directories under the tcllib top directory are

	modules/
	examples/
and	apps/

Each directory FOO under modules/ represents one package, sometimes
more. In the case of the latter the packages are usually related in
some way. Examples are the base64, math, and struct modules, with
loose (base64) to strong (math) relations between the packages.

Examples associated with a module FOO, if there are any, are placed
into the directory

	examples/FOO

Any type of distributable application can be found under apps/,
together with their documentation, if any. Note that the apps/
directory is currently not split into sub-directories.

Regarding the files in Tcllib, the most common types found are

	.tcl	Tcl code for a package.

	.man	Documentation for a package, in doctools format.

	.test	Test suite for a package, or part of. Based on tcltest.

	.bench	Performance benchmarks for a package, or part of.
		Based on modules/bench

	.pcx	Syntax rules for TclDevKit's tclchecker. Using these
		rules allows tclchecker to check the use of commands
		of a Tcllib package X without having to scan the
		implementation of X, i.e. its .tcl files.


Adding a new module
-------------------

Assuming that FOO is the name of the new module, and T is the toplevel
directory of the Tcllib sources

(1)	Create the directory T/modules/FOO and put all the files of
	the module into it. Note:

	* The file 'pkgIndex.tcl' is required.

	* Implementation files should have the extension '.tcl',
	  naturally.

	* If available, documentation should be in doctools format,
          and the files should have the extension '.man' for SAK to
          recognize them.

	* If available the testsuite(s) should use 'tcltest' and the
	  general format as used by the other modules in Tcllib
	  (declaration of minimally needed Tcl, tcltest, supporting
	  packages, etc.). The file(s) should have the extension
	  '.test' for SAK to recognize them.

	  Note that an empty testsuite, or a testsuite which does not
	  perform any tests is less than useful and will not be
	  accepted.

	* If available the benchmark(s) should use 'bench' and the
          general format as used by the other modules in Tcllib. The
          file(s) should have the extension '.bench' for SAK to
          recognize them.

	* Other files can be named and placed as the module sees fit.

(2)	If the new module has an example application A which is
	polished enough for general use, put this application into the
	file "T/apps/A.tcl", and its documentation into the file
	"T/apps/A.man". While documentation for the application is
	optional, it is preferred.

	For examples which are not full-fledged applications, a
	skeleton, or not really polished for use, etc., create the
	directory T/examples/FOO/ and put them there.

	A key difference is what happens to them on installation, and
	what the target audience is.

	The examples are for developers using packages in Tcllib,
	whereas the applications are also for users of Tcllib which do
	not have an interest in developing for and with it. As such,
	they are installed as regular commands, accessible through the
	PATH, and example files are not installed.

(3)	To make Tcllib's installer aware of FOO, edit the file

		T/support/installation/modules.tcl

	Add a line 'Module FOO $impaction $docaction $exaction'. The
	various actions describe to the installer how to install the
	implementation files, the documentation, and the examples.

	Add a line 'Application A' for any application A which was
	added to T/apps for FOO.

	The following actions are available:

	Implementation

		_tcl - Copy all .tcl files in T/modules/FOO into the installation.
		_tcr - See above, does it for .tcl files in subdirectories as well.
		_tci - _tcl + Copying of a tclIndex - special to modules 'math', 'control'.
		_msg - _tcl + Copying of subdir 'msgs' - special to modules 'dns', 'log'.
		_doc - _tcl + Copying of subdir 'mpformats' - special to module 'doctools'.
		_tex - _tcl + Copying of .tex files - special to module 'textutil'.

		The _null action, see below, is available in principle
		too, but a module without implementation does not make
		sense.

	Documentation

		_null - Module has no documentation, do nothing.
		_man  - Process the .man files in T/modules/FOO and
			install the results (nroff and/or HTML) in the
			proper location, as given to the installer.

	Examples

		_null - Module has no examples, do nothing
		_exa  - Copy the directory T/examples/FOO
			(recursively) to the install location for
			examples.


Testing modules
---------------

To run the testsuite of a module FOO in tcllib use the 'test run'
argument of sak.tcl, like so:

	% pwd
	/the/tcllib/toplevel/directory

	% ./sak.tcl test run FOO
or	% ./sak.tcl test run modules/FOO

To run the testsuites of all modules either invoke 'test run' without a
module name, or use 'make test'. The latter assumes that configure was
run for Tcllib before, i.e.:

	% ./sak.tcl test run
or	% ./sak.tcl test run
	% make test

In all of the above cases the result will be a combination of progress
display and testsuite log, showing for each module the tests that pass
or failed and how many of each in a summary at the end.

To get a detailed log, it is necessary to invoke 'test run' with
additional options.

First example:
	% ./sak.tcl test run -l LOG FOO

This shows the same short log on the terminal, and writes a detailed
log to the file LOG.log, and excerpts to other files (LOG.summary,
LOG.failures, etc.).

Second example:
	% ./sak.tcl test run -v FOO
	% make test > LOG

This writes the detailed log to stdout, or to the file LOG, instead of
the short log. In all cases, the detailed log contains a list of all
test cases executed, which failed, and how they failed (expected
versus actual results).

Note:
The commands
	% make test
and	% make test > LOG

are able to generate different output (short vs long log) because the
Makefile target contains code which detects that stdout has been
redirected to a file and acts accordingly.

Non-developers should reports problems in Tcllib's bug tracker.
Information about its location and the relevant category can be found
in the section 'BUGS, IDEAS, FEEDBACK' of the manpage of the module
and/or package.

Module documentation
--------------------

The main format used for the documentation of packages in Tcllib is
'doctools', the support packages of which are part of Tcllib, see the
module 'doctools'.

To convert this documentation to HTML or nroff manpages, or some other
format use the 'doc' argument of sak.tcl, like so:

	% pwd
	/the/tcllib/toplevel/directory

	% ./sak.tcl doc html FOO
or	% ./sak.tcl doc html modules/FOO

The result of the conversion can be found in the newly-created 'doc'
directory in the current working directory.

The set of formats the documentation can be converted into can be
queried via

	% ./sak.tcl help doc


To convert the documentation of all modules either invoke 'test run'
without a module name, or use 'make html-doc', etc.. The latter
assumes that configure was run for Tcllib before, i.e.:

	% ./sak.tcl doc html
	% make html-doc

Note the special format 'validate'. Using this format does not convert
the documentation to anything (and the sub-directory 'doc' will not be
created), it just checks that the documentation is syntactically
correct. I.e.

	% ./sak.tcldoc validate modules/FOO
	% ./sak.tcldoc validate


Validating modules
------------------

Running the testsuite of a module, or checking the syntax of its
documentation (see the previous sections) are two forms of validation.

The 'validate' command of sak.tcl provides a few more. The online
documentation of this command is available via

	% ./sak.tcl help validate

The validated parts are man pages, testsuites, version information,
and syntax. The latter only if various static syntax checkers are
available on the PATH, like TclDevKit's tclchecker.

Note that testsuite validation is not the execution of the testsuites,
only if a package has a testsuite or not.

It is strongly recommended to validate a module before committing any
type of change made to it.

It is recommended to validate all modules before committing any type
of change made to one of them. We have package inter-dependencies
between packages in Tcllib, thus changing one package may break
others, and just validating the changed package will not catch such
problems.


Writing Tests
-------------

While a previous section talked about running the testsuite for a
module and the packages therein this has no meaning if the module in
question has no testsuites at all.

This section gives a very basic overview on methodologies for writing
tests and testsuites.

First there are "drudgery" tests. Written to check absolutely basic
assumptions which should never fail.

Example:

	For a command FOO taking two arguments, three tests calling it
	with zero, one, and three arguments. The basic checks that the
	command fails if it has not enough arguments, or too many.

After that come the tests checking things based on our knowledge of
the command, about its properties and assumptions. Some examples based
on the graph operations added during Google's Summer of Code 2009.

**	The BellmanFord command in struct::graph::ops takes a
	_startnode_ as argument, and this node should be a node of the
	graph. equals one test case checking the behavior when the
	specified node is not a node a graph.

	This often gives rise to code in the implementation which
	explicitly checks the assumption and throws a nice error.
	Instead of letting the algorithm fails later in some weird
	non-deterministic way.

	Such checks cannot be done always. The graph argument for
	example is just a command in itself, and while we expect it to
	exhibit a certain interface, i.e. set of sub-commands aka
	methods, we cannot check that it has them, except by actually
	trying to use them. That is done by the algorithm anyway, so
	an explicit check is just overhead we can get by without.

**	IIRC one of the distinguishing characteristic of either
	BellmanFord and/or Johnson is that they are able to handle
	negative weights. Whereas Dijkstra requires positive weights.

	This induces (at least) three testcases ... Graph with all
	positive weights, all negative, and a mix of positive and
	negative weights.

	Thinking further does the algorithm handle the weight '0' as
	well ? Another test case, or several, if we mix zero with
	positive and negative weights.

**	The two algorithms we are currently thinking about are about
	distances between nodes, and distance can be 'Inf'inity,
	i.e. nodes may not be connected. This means that good test
	cases are

	(1)	Strongly connected graph
	(2)	Connected graph
	(3)	Disconnected graph.

	At the extremes of (1) and (3) we have the fully connected
	graphs and graphs without edges, only nodes, i.e. completely
	disconnected.

**	IIRC both of the algorithms take weighted arcs, and fill in a
	default if arcs are left unweighted in the input graph.

	This also induces three test cases:

	(1)	Graph will all arcs with explicit weights.
	(2)	Graph without weights at all.
	(3)	Graph with mixture of weighted and unweighted graphs.


What was described above via examples is called 'black-box' testing.
Test cases are designed and written based on our knowledge of the
properties of the algorithm and its inputs, without referencing a
particular implementation.

Going further, a complement to 'black-box' testing is 'white-box'. For
this we know the implementation of the algorithm, we look at it and
design our tests cases so that they force the code through all
possible paths in the implementation. Wherever a decision is made we
have a test cases forcing a specific direction of the decision, for
all possible directions.

In practice I often hope that the black-box tests I have made are
enough to cover all the paths, obviating the need for white-box tests.

So, if you, dear reader, now believe that writing tests for an
algorithm takes at least as much time as coding the algorithm, and
often more time, then you are completely right. It does. Much more
time. See for example also http://sqlite.org/testing.html, a writeup
on how the Sqlite database engine is tested.



An interesting connection is to documentation. In one direction, the
properties you are checking with black-box testing are properties
which should be documented in the algorithm man page. And conversely,
if you have documentation of properties of an algorithm then this is a
good reference to base black-box tests on.

In practice test cases and documentation often get written together,
cross-influencing each other. And the actual writing of test cases is
a mix of black and white box, possibly influencing the implementation
while writing the tests. Like writing test for 'startnode not in input
graph' serving as reminder to put in a check for this into the code.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
























































































































































































































































































































































































































































































































































































































































































































































































































Added devdoc/cvs.branches.fig.

































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#FIG 3.2
Landscape
Center
Inches
Letter  
100.00
Single
-2
1200 2
6 3000 2025 5400 2400
4 0 12 50 0 0 14 0.0000 4 150 2385 3000 2175 Point releases are branched\001
4 0 12 50 0 0 14 0.0000 4 150 1530 3000 2370 from RELEASES\001
-6
6 2400 750 5700 1200
4 0 1 50 0 0 14 0.0000 4 195 3225 2400 900 Developer performs internal releases,\001
4 0 1 50 0 0 14 0.0000 4 195 3285 2400 1095 merging from HEAD into RELEASES\001
-6
2 1 0 4 0 7 50 0 -1 0.000 0 0 7 1 0 2
	2 1 4.00 240.00 480.00
	 300 600 5700 600
2 1 0 2 1 7 50 0 -1 0.000 0 0 -1 1 0 2
	2 1 2.00 120.00 240.00
	 2100 600 2400 1800
2 1 0 5 12 7 50 0 -1 0.000 0 0 -1 1 0 3
	2 1 5.00 300.00 600.00
	 2700 1800 3000 3000 5700 3000
2 1 0 4 17 7 50 0 -1 0.000 0 0 7 1 0 3
	2 1 4.00 240.00 480.00
	 1200 600 1500 1800 5700 1800
4 0 0 50 0 0 14 0.0000 4 195 2835 3150 1575 Staging for release : RELEASES\001
4 0 0 50 0 0 14 0.0000 4 195 1905 3900 300 Development : HEAD\001
4 0 0 50 0 0 14 0.0000 4 150 930 4800 2700 Tcllib 1.2.0\001

Added devdoc/devguide.html.





































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<!- Guide for Tcllib developers -->

<h1>Guide for Tcllib developers.
</h1>
<hr>

<h2>CVS Repository
</h2>
<table><tr><td valign=top>
      <!-- The local source of this image is
		tcllib/devel/cvs.branches.*
	-->
      <img src="http://sourceforge.net/dbimage.php?id=2221">
</td><td valign=top><p>

The CVS repository for Tcllib contains two main branches, the HEAD for
development, and RELEASES as the staging area for official
releases. At RELEASES the minor branches containing the various
official releases are anchored at.
</p></td></tr></table>

<p>All the branches are of interest to the developers for
      Tcllib. Ongoing development happens in HEAD, which can be
      unstable or may not work at all. Whenever a developer considers
      a piece of code, or module, he is responsible for as
      sufficiently stable she has to perform an internal release which
      merges this part from HEAD into RELEASES. Tools to help with
      this will be provided.
</p>

<p>The branches for the official releases of tcllib are of interest to
      a developer because it is expected that fixes for important bugs
      not only go into the HEAD branch but also into the release
      branches for the release they were found in and all releases
      following that one. This is to allow the release manager to
      create patch releases of existing releases distributing important
      bugfixes as well.
</p>

<p>Version numbers for modules are handled as described below. This
      way of handling them was chosen so that the modules in the
      development branch always uses version numbers different from
      the version numbers in the official releases made so far.
</p>
<ul>
<li>Whenever an internal release of a module FOO is done, the
	developer performing this internal release has to increment
	the version number of the module <b>after</b> the release was
	executed.
</ul>

Added devdoc/installation.txt.











































































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
Tcllib installation directory layout
====================================

This document describes the possible layouts for an installed tcllib,
discusses their pro and contra and makes a choice for Tcllib 1.4. A
roadmap of changes in the future is made available as appendix.

[L1/D] Deep layout
------------------

	This is the layout of Tcllib 1.3 (and versions before that).

	A single directory tcllib<version> is created, and all
	subdirectories of the 'modules' subdirectory in the
	distribution is copied into it. This is restricted at large to
	*.tcl files, with exception made for some modules with special
	needs.

	Pro:
	Contra:
		Makes the handling of the various package indices,
		well, not difficult, but uncomfortable.


[L2/Fa] Flat layout 1
---------------------

	A directory is created for each module of tcllib.

	Pro:
		Handling of package indices is easier than for L1/D, a
		toplevel index file with all its problems is not
		required anymore.

	Contra:
		Directories should be versioned to avoid conflicts
		between multiple releases. modules have no
		version. This can be faked for modules containing one
		package, but not for the modules with more.


[L2/Fb] Flat layout 2
---------------------

	A directory is created for each package in tcllib.

	Pro
		Handling of package indices is easy, one per package.

	Contra:
		Modules containing more than one package are difficult
		to handle. The system has to split them into the
		individual packages. This rendered very difficult
		because of shared package index files.
	
		This can be solved by moving tcllib (back) towards of
		one package per module. When that goal is reached
		L2/Fa and L2/Fb become the same, and the contra for
		L2/Fa vanishes too as an exact version number can be
		associated with each directory.

Chosen layout for Tcllib 1.4
----------------------------

	L2/D

	Despite the problems with package indices the contras against
	the flat structures are too strong at this point in
	time. Automatic solutions are not really possible, or require
	a very high effort.

Roadmap
-------
	Change the module directories of tcllib to contain exactly one
	package per directory, with appropriate index (and meta data).

	This not only makes sense for easier handling of installation
	and package indices, but also in the greater context of
	wrapping code for deployment.


-----------------------------------
This document is in the public domain.

			Andreas Kupries	<andreas_kupries@users.sf.net>

Deleted devdoc/parts/b_critcl.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

While the majority of Tcllib consists of packages written in pure Tcl
a number of packages also have [term accelerators] associated with them.

These are [syscmd critcl]-based C packages whose use will boost the
performance of the packages using them.

These accelerators are optional, and they are not built by default.
If they are built according to the instructions below then they will
also be installed as well.

[para] To build the accelerators the normally optional dependency on
       [syscmd critcl] becomes required.

[para] To build and install Tcllib with the accelerators in a
       Unix-like environment invoke:

[example {
  ./configure
  make critcl  # Builds the shared library and package holding
               # the accelerators, tcllibc
  make install # Installs all packages, including the new tcllibc.
}]

[para] The underlying tool is [file sak.tcl] in the toplevel directory
of Tcllib and the command [cmd {make critcl}] is just a wrapper around

[example {
  ./sak.tcl critcl
}]

[para] Therefore in a Windows environment instead invoke

[example {
  ./sak.tcl critcl
  ./installer.tcl
}]

from within a DOS window, i.e. [syscmd cmd.exe].
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<














































































Deleted devdoc/parts/b_tooling.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

The core of Tcllib's build system is the script [file installer.tcl]
found in the toplevel directory of a checkout or release.

[para] The
       [example {
         configure ; make install
       }]
       setup available to
       developers on Unix-like systems is just a wrapper around it.

       To go beyond the standard embodied in the wrapper it is
       necessary to directly invoke this script.

[para] On Windows system using it directly is the only way to invoke
       it.

[para] For basic help invoke it as

       [example {
         ./installer.tcl -help
       }]

       This will print a short list of all the available options to
       the standard output channel.

[para] The commands associated with the various [term install] targets
       in the [term Makefile.in] for Unix can be used as additional
       examples on how to use this tool as well.

[para] The installer can operate in GUI and CLI modes.

       By default it chooses the mode automatically, based on if the
       Tcl package [package Tk] can be used or not.

       The option [option -no-gui] can be used to force CLI mode.

[para] Note that it is possible to specify options on the command line
       even if the installer ultimatively selects GUI mode. In that
       case the hardwired defaults and the options determine the data
       presented to the user for editing.

[para] The installer will select a number of defaults for the
       locations of packages, examples, and documentation, and also
       the format of the documentation. The user can overide these
       defaults in the GUI, or by specifying additional options.

       The defaults depend on the platform detected (Unix/Windows) and
       on the [syscmd tclsh] executable used to run the installer.

[para][emph Options]

[list_begin options]
[opt_def -help]

Show the list of options explained here on the standard output channel
and exit.

[opt_def +excluded]

Include deprecated packages in the installation.

[opt_def -no-gui]

Force command line operation of the installer

[opt_def -no-wait]

In CLI mode the installer will by default ask the user to confirm that
the chosen configuration (destination paths, things to install) is
correct before performing any action. Using this option causes the
installer to skip this query and immediately jump to installation.

[opt_def -app-path [arg path]]
[opt_def -example-path [arg path]]
[opt_def -html-path [arg path]]
[opt_def -nroff-path [arg path]]
[opt_def -pkg-path [arg path]]

Declare the destination paths for the applications, examples, html
documentation, nroff manpages, and packages. The defaults are derived
from the location of the [syscmd tclsh] used to run the installer.

[opt_def -dry-run]
[opt_def -simulate]

Run the installer without modifying the destination directories.

[opt_def -apps]
[opt_def -no-apps]
[opt_def -examples]
[opt_def -no-examples]
[opt_def -pkgs]
[opt_def -no-pkgs]
[opt_def -html]
[opt_def -no-html]
[opt_def -nroff]
[opt_def -no-nroff]

(De)activate the installation of applications, examples, packages,
html documentation, and nroff manpages.

[para] Applications, examples, and packages are installed by default.

[para] On Windows the html documentation is installed by default.

[para] On Unix the nroff manpages are installed by default.

[list_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































































































































Deleted devdoc/parts/b_unix.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

For [term Unix]-like environments Tcllib comes with the standard set
of files to make

[example {
  ./configure
  make install
}]

a suitable way of installing it.

This is a standard non-interactive install automatically figuring out
where to place everything, i.e. packages, applications, and the
manpages.

[para] To get a graphical installer invoke

[example {
  ./installer.tcl
}]

instead.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<












































Deleted devdoc/parts/b_windows.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

In a Windows environment we have the [cmd installer.tcl] script to
perform installation.

[para] If the desired [syscmd tclsh] is associated [file .tcl] files
       then double-clicking / opening the [cmd installer.tcl] is
       enough to invoke it in graphical mode.

       This assumes that [term Tk] is installed and available as well.

[para] Without [term Tk] the only way to invoke the installer are to
       open a DOS window, i.e. [syscmd cmd.exe], and then to invoke
      
[example {
  ./installer.tcl
}]

inside it.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































Deleted devdoc/parts/d_bf_branchcmds.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

In the hope of engendering good work practices now a few example
operations which will come up with branches, and their associated
fossil command (sequences).

[list_begin definitions]

[comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~]
[def [emph Awareness]]
[include d_op_aware.inc]

[comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~]
[def [emph {Clean checkouts}]]
[include d_op_clean.inc]

[comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~]
[def [emph {Starting a new branch}]]
[include d_op_branch_open.inc]

[comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~]
[def [emph {Merging a branch into trunk}]]
[include d_op_branch_close.inc]

[comment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~]
[def [emph {Merging from trunk}]]
[include d_op_branch_import.inc]

[list_end]

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































Deleted devdoc/parts/d_bf_branches.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Given the constraints placed on the [term trunk] branch of the
repository it is (strongly) recommended to perform any development
going beyond trivial changes on a non-trunk branch.

[para] Outside of the trunk developers are allowed to commit
       intermediate broken states of their work.

       Only at the end of a development cycle, when the relevant
       branch is considered ready for merging, will it be necessary to
       perform full the set of validations ensuring that the merge to
       come will create a good commit on trunk.

[para] Note that while a review from a second developer is not a
       required condition for merging a branch it is recommended to
       seek out such an independent opinion as a means of
       cross-checking the work.

[para] It also recommended to give any new branch a name which aids in
       determining additional details about it. Examples of good
       things to stick into a branch name would be

[list_begin itemized]
[item]	Developer (nick)name
[item]	Ticket hash/reference
[item]	One or two keywords applicable to the work
[item]	...
[list_end]

[para] Further, while most development branches are likely quite
       short-lived, no prohibitions exist against making longer-lived
       branches.

       Creators should however be mindful that the longer such a
       branch exists without merges the more divergent they will tend
       to be, with an associated increase in the effort which will
       have to be spent on either merging from and merging to trunk.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































Deleted devdoc/parts/d_bf_dependencies.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

Regarding packages and dependencies between them Tcllib occupies a
middle position between two extremes:

[list_begin enumerated]

[enum] On one side a strongly interdependent set of packages, usually
       by a single author, for a single project. Looking at my
       (Andreas Kupries) own work examples of such are
       [uri https://core.tcl.tk/akupries/marpa/index Marpa],
       [uri https://core.tcl.tk/akupries/crimp/index CRIMP],
       [uri https://core.tcl.tk/akupries/kinetcl/index Kinetcl], etc.

[para] For every change the author of the project handles all the
       modifications cascading from any incompatibilities it
       introduced to the system.

[enum] On the other side, the world of semi-independent projects by
       many different authors where authors know what packages their
       own creations depend on, yet usually do not know who else
       depends on them.

[para] The best thing an author making an (incompatible) change to
       their project can do is to for one announce such changes in
       some way, and for two use versioning to distinguish the code
       before and after the change.

[para] The world is then responsible for adapting, be it by updating
       their own projects to the new version, or by sticking to the
       old.

[list_end]

As mentioned already, Tcllib lives in the middle of that.

[para] While we as maintainers cannot be aware of all users of
       Tcllib's packages, and thus have to rely on the mechanisms
       touched on in point 2 above for that, the dependencies between
       the packages contained in Tcllib are a different matter.

[para] As we are collectively responsible for the usability of Tcllib
       in toto to the outside world, it behooves us to be individually
       mindful even of Tcllib packages we are not directly
       maintaining, when they depend on packages under our
       maintainership.

       This may be as simple as coordinating with the maintainers of
       the affected packages.

       It may also require us to choose how to adapt affected packages
       which do not have maintainers, i.e. modify them to use our
       changed package properly, or modify them to properly depend on
       the unchanged version of our package.

[para] Note that the above is not only a chore but an opportunity as
       well.

       Additional insight can be had by forcing ourselves to look at
       our package and the planned change(s) from an outside
       perspective, to consider the ramifications of our actions on
       others in general, and on dependent packages in particular.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































Deleted devdoc/parts/d_bf_trunk.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

The management and use of branches is an important part of working
with a [term {Distributed Version Control System}] ([term DVCS]) like
[uri https://www.fossil-scm.org/ fossil].

[para] For Tcllib the main branch of the collection is
       [term trunk]. In [term git] this branch would be called
       [term master], and this is exactly the case in the
       [uri https://github.com/tcltk/tcllib/ {github mirror}] of
       Tcllib.

[para] To properly support debugging [emph {each commit}] on this
       branch [emph {has to pass the entire testsuite}] of the
       collection. Using bisection to determine when an issue appeared
       is an example of an action made easier by this constraint.

[para] This is part of our collective responsibility for the usability
       of Tcllib in toto to the outside world.

       As [term fossil] has no mechanism to enforce this condition
       this is handled on the honor system for developers and maintainers.

[para] To make the task easier Tcllib comes with a tool
       ([file sak.tcl]) providing a number of commands in
       support. These commands are explained in the following sections
       of this guide.

[para] While it is possible and allowed to commit directly to trunk
       remember the above constraint regarding the testsuite, and the
       coming notes about other possible issues with a commit.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




























































Deleted devdoc/parts/d_bf_versions.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
In Tcllib all changes to a package have to come with an increment of
its version number. What part is incremented (patchlevel, minor, major
version) depends on the kind of change made. With multiple changes in
a commit the highest "wins".

[para] When working in a development branch the version change can be
       deferred until it is time to merge, and then has to cover all
       the changes in the branch.

[para] Below a list of the kinds of changes and their associated
       version increments:

[list_begin definitions]
[def [term {D - documentation}]] No increment
[def [term {T - testsuite}]] No increment
[def [term {B - bugfix}]] Patchlevel
[def [term {I - implementation tweak}]] Patchlevel
[def [term {P - performance tweak}]] Patchlevel
[def [term {E - backward-compatible extension}]] Minor
[def [term {API - incompatible change}]] Major
[list_end]

[para] Note that a commit containing a version increment has to
       mention the new version number in its commit message, as well
       as the kind of change which caused it.

[para] Note further that the version number of a package currently
       exists in three places. An increment has to update all of them:

[list_begin enumerated]
[enum] The package implementation.
[enum] The package index ([file pkgIndex.tcl])
[enum] The package documentation.
[list_end]

[para] The [file sak.tcl] command [cmd {validate version}] helps
       finding discrepancies between the first two.

       All the other [cmd validate] methods are also of interest to
       any developer. Invoke it with

       [example { sak.tcl help validate }]

       to see their documentation.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
























































































Deleted devdoc/parts/d_branchflow.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
[comment {===================================================================}]
[subsection {Package Dependencies}]
[include d_bf_dependencies.inc]

[comment {===================================================================}]
[subsection Trunk]
[include d_bf_trunk.inc]

[comment {===================================================================}]
[subsection Branches]
[include d_bf_branches.inc]

[comment {===================================================================}]
[subsection {Working with Branches}]
[include d_bf_branchcmds.inc]

[comment {===================================================================}]
[subsection {Version numbers}]
[include d_bf_versions.inc]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






































Deleted devdoc/parts/d_contrib.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

As a contributor to Tcllib you are committing yourself to:

[list_begin enumerated]

[enum] keep the guidelines written down in
       [term {Tcl Community - Kind Communication}] in your mind.
       The main point to take away from there is
       [emph {to be kind to each other}].

[enum] Your contributions getting distributed under a BSD/MIT license.
       For the details see [term {Tcllib - License}]

[list_end]

Contributions are made by entering tickets into our tracker, providing
patches, bundles or branches of code for inclusion, or posting to the
Tcllib related mailing lists.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































Deleted devdoc/parts/d_dirlayout.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

[subsection {Main Directories}]

The main directories in the Tcllib toplevel directory and of interest
to a developer are:

[list_begin definitions]

[def [file modules]]

Each child directory represents one or more packages.

In the case of the latter the packages are usually related in some
way. Examples are [file base64], [file math], and [file struct], with
loose (base64) to strong (math) relations between the packages in the
directory.

[def [file apps]]

This directory contains all the installable applications, with their
documentation. Note that this directory is currently [emph not] split
into sub-directories.

[def [file examples]]

Each child directory [file foo] contains one or more example
application for the packages in [file modules/foo]. These examples are
generally not polished enough to be considered for installation.

[list_end]

[subsection {More Directories}]

[list_begin definitions]

[def [file config]]

This directory contains files supporting the Unix build system,
i.e. [file configure] and [file Makefile.in].

[def [file devdoc]]

This directories contains the doctools sources for the global
documentation, like this document and its sibling guides.

[def [file embedded]]

This directory contains the entire documentation formatted for
[term HTML] and styled to properly mix into the web site generated by
fossil for the repository.

[para] This is the documentation accessible from the Tcllib home
directory, represented in the repository as [file embedded/index.md].

[def [file idoc]]

This directory contains the entire documentation formatted for
[term nroff] and [term HTML], the latter without any styling.
This is the documentation which will be installed.

[def [file support]]

This directory contains the sources of internal packages and utilities
used in the implementation of the [file installer.tcl] and
[file sak.tcl] scripts/tools.

[list_end]

[subsection {Top Files}]

[list_begin definitions]
[def [file aclocal.m4]]
[def [file configure]]
[def [file configure.in]]
[def [file Makefile.in]]

These four files comprise the Unix build system layered on top of the
[file installer.tcl] script.

[def [file installer.tcl]]

The Tcl-based installation script/tool.

[def [file project.shed]]

Configuration file for [term {Sean Wood}]'s [syscmd PracTcl]
buildsystem.

[def [file sak.tcl]]
This is the main tool for developers and release managers, the
[term {Swiss Army Knife}] of management operations on the collection.

[def [file ChangeLog]]

The log of changes to the global support, when the sources were held
in [term CVS]. Not relevant any longer with the switch to the
[term fossil] SCM.

[def [file license.terms]]

The license in plain ASCII. See also [term {Tcllib - License}] for the
nicely formatted form. The text is identical.

[def [file README.md]]
[def [file .github/CONTRIBUTING.md]]
[def [file .github/ISSUE_TEMPLATE.md]]
[def [file .github/PULL_REQUEST_TEMPLATE.md]]

These markdown-formatted documents are used and shown by the github
mirror of these sources, pointing people back to the official location
and issue trackers.

[def [file DESCRIPTION.txt]]
[def [file STATUS]]
[def [file tcllib.spec]]
[def [file tcllib.tap]]
[def [file tcllib.yml]]

????

[list_end]

[subsection {File Types}]

The most common file types, by file extension, are:

[list_begin definitions]

[def [file .tcl]]
Tcl code for a package, application, or example.

[def [file .man]]
Doctools-formatted documentation, usually for a package.

[def [file .test]]
Test suite for a package, or part of.
Based on [package tcltest].

[def [file .bench]]
Performance benchmarks for a package, or part of.
Based on [file modules/bench].

[def [file .pcx]]
Syntax rules for [term TclDevKit]'s [syscmd tclchecker]. Using these
rules allows the checker to validate the use of commands of a Tcllib
package [package foo] without having to scan the [file .tcl] files
implementing it.

[list_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































































































































































































Deleted devdoc/parts/d_documentation.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

The standard format used for documentation of packages and other
things in Tcllib is [term doctools].

Its supporting packages are a part of Tcllib, see the directories
[file modules/doctools] and [file modules/dtplite]. The latter is
an application package, with the actual application
[file apps/dtplite] a light wrapper around it.

[para] Tcllib developers gain access to these through the [cmd doc]
method of the [file sak.tcl] tool, another (internal) wrapper around
the [file modules/dtplite] application package.

[comment {===================================================================}]
[subsection {Generate documentation for a specific module}]

Invoke either

[example {  ./sak.tcl doc html foo }]

or

[example {  ./sak.tcl doc html modules/foo }]

to generate HTML for the documentation found in the module [file foo].

Instead of [const html] any other supported format can be used here,
of course.

[para] The generated formatted documentation will be placed into a
directory [file doc] in the current working directory.

[comment {===================================================================}]
[subsection {Generate documentation for all modules}]

Invoke the tool without a module name, i.e.

[example {  ./sak.tcl doc html }]

to generate HTML for the documentation found in all modules.

Instead of [const html] any other supported format can be used here,
of course.

[para] The generated formatted documentation will be placed into a
directory [file doc] in the current working directory.

[comment {===================================================================}]
[subsection {Available output formats, help}]

Invoke the tool as

[example {  ./sak.tcl help doc }]

to see the entire set of supported output formats which can be
generated.

[comment {===================================================================}]
[subsection {Validation without output}]

Note the special format [const validate].

[para] Using this value as the name of the format to generate forces
the tool to simply check that the documentation is syntactically
correct, without generating actual output.

[para] Invoke it as either

[example {  ./sak.tcl doc validate (modules/)foo }]

or

[example {  ./sak.tcl doc validate }]

to either check the packages of a specific module or check all of
them.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
























































































































































Deleted devdoc/parts/d_installation.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
A last thing to consider when adding a new package to the collection
is installation.

[para] How to [emph use] the [file installer.tcl] script is documented
in [term {Tcllib - The Installer's Guide}].

[para] Here we document how to extend said installer so that it may
install new package(s) and/or application(s).

[para] In most cases only a single file has to be modified, the
[file support/installation/modules.tcl] holding one command per module
and application to install.

[para] The relevant commands are:

[list_begin definitions]

[call [cmd Module] [arg name] \
      	   [arg code-action] \
      	   [arg doc-action] \
	   [arg example-action]]

Install the packages of module [arg name], found in
[file modules/[arg name]].

[para] The [arg code-action] is responsible for installing the
packages and their index. The system currently provides

[list_begin definitions]

[def [cmd _tcl]] Copy all [file .tcl] files found in
[file modules/[arg name]] into the installation.

[def [cmd _tcr]] As [cmd _tcl], copy the [file .tcl] files found in
the subdirectories of [file modules/[arg name]] as well.

[def [cmd _tci]] As [cmd _tcl], and copy the [file tclIndex.tcl] file
as well.

[def [cmd _msg]] As [cmd _tcl], and copy the subdirectory [file msgs]
as well.

[def [cmd _doc]] As [cmd _tcl], and copy the subdirectory
[file mpformats] as well.

[def [cmd _tex]] As [cmd _tcl], and copy [file .tex] files as well.

[list_end]

[para] The [arg doc-action] is responsible for installing the package
documentation. The system currently provides

[list_begin definitions]
[def [cmd _null]] No documentation available, do nothing.

[def [cmd _man]] Process the [file .man] files found in
[file modules/[arg name]] and install the results (nroff and/or HTML)
in the proper location, as given to the installer.

[para] This is actually a fallback, normally the installer uses the
pre-made formatted documentation found under [file idoc].

[list_end]

[para] The [arg example-action] is responsible for installing the
examples. The system currently provides

[list_begin definitions]
[def [cmd _null]] No examples available, do nothing.

[def [cmd _exa]] Copy the the directory [file examples/[arg name]]
recursively to the install location for examples.

[list_end]

[call [cmd Application] [arg name]]

Install the application with [arg name], found in [file apps].


[call [cmd Exclude] [arg name]]

This command signals to the installer which of the listed modules to
[emph not] install. I.e. they name the deprecated modules of Tcllib.

[list_end]

[para] If, and only if the above actions are not suitable for the new
module then a second file has to be modified,
[file support/installation/actions.tcl].

[para] This file contains the implementations of the available
actions, and is the place where any custom action needed to handle the
special circumstances of module has to be added.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




























































































































































































Deleted devdoc/parts/d_maintain.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

When contributing one or more packages for full inclusion into Tcllib
you are committing yourself to

[list_begin enumerated]

[enum] Keep the guidelines written down in
       [term {Tcl Community - Kind Communication}]
       (as any contributor) in your mind. The main point to take away
       from there is [emph {to be kind to each other}].

[enum] Your packages getting distributed under a BSD/MIT license.  For
       the details see [term {Tcllib - License}]

[enum] Maintenance of the new packages for a period of two years under
       the following rules, and responsibilities:

       [list_begin enumerated]

       [enum] A maintainer may step down after the mandatory period as
       	      they see fit.

       [enum] A maintainer may step down before the end of the
      	      mandatory period, under the condition that a replacement
      	      maintainer is immediately available and has agreed to
      	      serve the remainder of the period, plus their own
      	      mandatory period (see below).

       [enum] When stepping down without a replacement maintainer
      	      taking over the relevant packages have to be flagged as
      	      [const unmaintained].

       [enum] When a replacement mantainer is brought in for a package
      	      it is (kept) marked as [const maintained] (again).

       [para] A replacement maintainer is bound by the same rules as
	      the original maintainer, except that the mandatory
	      period of maintenance is shortened to one year.

       [enum] For any [const unmaintained] package a contributor
       	      interested in becoming its maintainer can become so by
       	      flagging them as [const maintained] with their name and
       	      contact information, committing themselves to the rules
       	      of a replacement maintainer (see previous point).

       [enum] For any already [const maintained] package a contributor
       	      interested in becoming a co-maintainer can become so
       	      with the agreement of the existing maintainer(s),
       	      committing themselves to the rules of a replacement
       	      maintainer (see two points previous).

       [list_end]

       [para] The responsibilities as a maintainer include:

       [list_begin enumerated]

       [enum] Watching Tcllib's ticket tracker for bugs, bug fixes,
       	      and feature requests related to the new packages.

       [enum] Reviewing the aforementioned tickets, rejecting or
       	      applying them

       [enum] Coordination and discussion with ticket submitter during
       	      the development and/or application of bug fixes.

       [list_end]

[enum] Follow the [sectref {Branching and Workflow}] of this guide.

[list_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<














































































































































Deleted devdoc/parts/d_op_aware.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

When developing we have to keep ourselves aware of the context of our
work. On what branch are we ? What files have we changed ? What new
files are not yet known to the repository ? What has happened remotely
since we used our checkout ?

The answers to these questions become especially important when using
a long-lived checkout and coming back to it after some time away.

[para] Commands to answer questions like the above are:

[list_begin definitions]

[def [cmd {fossil pull}]]

       Get all changes done on the remote since the last pull or sync
       from it. This has to be done first, before any of the commands
       below.

[para] Even if the commit in our checkout refers to the branch we want
       right now control operations committed to the remote may have
       changed that from underneath us.

[def [cmd {fossil info | grep tags}]]
[def [cmd {fossil branch list | grep '\*'}]]

       Two different ways of determining the branch our checkout is
       on.

[def [cmd {fossil timeline}]]

       What have we (and others) done recently ?

[para] [emph Attention], this information is very likely outdated, the
       more the longer we did not use this checkout.

       Run [cmd {fossil pull}] first to get latest information from
       the remote repository of the project.

[def [cmd {fossil timeline current}]]

       Place the commit our checkout is based on at the top of the
       timeline.

[def [cmd {fossil changes}]]

       Lists the files we have changed compared to the commit the
       checkout is based on.

[def [cmd {fossil extra}]]

       Lists the files we have in the checkout the repository does not
       know about. This may be leftover chaff from our work, or
       something we have forgotten to [cmd {fossil add}] to the
       repository yet.

[list_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


















































































































Deleted devdoc/parts/d_op_branch_close.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

Be aware of where you are (see first definition).

[para] Ensure that you have clean checkout (see second definition).

       In the full-blown sequence (zig-zag) it is [emph required], due
       to the merging from trunk. In the shorter sequence it is only
       desired. That said, keeping the checkout clean before
       any major operations is a good habit to have, in my opinion.

[para] The full-blown sequencing with checks all the way is to

[list_begin enumerated]

[enum] Validate the checkout, i.e. last commit on your branch. Run the
       full test suite and other validations, fix all the issues which
       have cropped up.

[enum] Merge the latest state of the [term trunk] (see next definition).

[enum] Validate the checkout again. The incoming trunk changes may
       have broken something now. Do any required fixes.

[enum] Now merge to the trunk using

[example {
    fossil update trunk
    fossil merge --integrate YOUR_BRANCH
}]

[enum] At this point the checkout should be in the same state as at
       the end of point (3) above, because we resolved any issues with
       the trunk already. Thus a simple

[example {
    fossil commit ...
}]

       should be sufficient now to commit the merge back and close the
       branch (due to the [option --integrate] we used on the merge).

[para] The more paranoid may validate the checkout a third time before
       commiting.
[list_end]

[para] I call this a [term {zig-zag merge}] because of how the arrows
       look in the timeline, from trunk to feature branch for the
       first merge, and then back for the final merge.

[para] A less paranoid can do what I call a [term {simple merge}],
       which moves step (2) after step (4) and skips step (3)
       entirely. The resulting shorter sequence is

[list_begin enumerated]
[enum] Validate
[enum] Merge to trunk
[enum] Validate again
[enum] Commit to trunk
[list_end]

The last step after either zig-zag or plain merge is to

[example {
    fossil sync
}]

This saves our work to the remote side, and further gives us any other
work done while we were doing our merge. It especially allows us to
check if we raced somebody else, resulting in a split trunk.

[para] When that happens we should coordinate with the other developer
       on who fixes the split, to ensure that we do not race each
       other again.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


















































































































































Deleted devdoc/parts/d_op_branch_import.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

Be aware of where you are (see first definition).

[para] Ensure that you have clean checkout (see second definition).
       It is [emph required].
       
[para] In most situations you want to import the latest commit of
       branch [term trunk] (or other origin). To get it use

[example {
    fossil pull
}]

[para] With that done we can now import this commit into our current
       branch with

[example {
    fossil merge trunk
}]

[para] Even if [syscmd fossil] does not report any conflicts it is a
       good idea to check that the operation has not broken the new
       and/or changed functionality we are working on.

[para] With the establishment of a good merge we then save the state
       with

[example {
    fossil commit ...
}]

before continuing development.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
































































Deleted devdoc/parts/d_op_branch_open.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

Be aware of where you are (see first definition).

[para] Ensure that you have clean checkout (see second definition).
       It is [emph required].

[para] In most situations you want to be on branch [term trunk], and
       you want to be on the latest commit for it. To get there use

[example {
    fossil pull
    fossil update trunk
}]

If some other branch is desired as the starting point for the coming
work replace [term trunk] in the commands above with the name of that
branch.

[para] With the base line established we now have two ways of creating
       the new branch, with differing (dis)advantages.

       The simpler way is to

[example {
    fossil branch new NAME_OF_NEW_BRANCH
}]

and start developing. The advantage here is that you cannot forget to
create the branch. The disadvantages are that we have a branch commit
unchanged from where we branched from, and that we have to use
high-handed techniques like hiding or shunning to get rid of the
commit should we decide to abandon the work before the first actual
commit on the branch.

[para] The other way of creating the branch is to start developing,
and then on the first commit use the option [option --branch] to tell
[syscmd fossil] that we are starting a branch now. I.e. run

[example {
    fossil commit --branch NAME_OF_NEW_BRANCH ...
}]

where [term ...] are any other options used to supply the commit
message, files to commit, etc.

[para] The (dis)advantages are now reversed.

[para] We have no superflous commit, only what is actually
       developed. The work is hidden until we commit to make our first
       commit.

[para] We may forget to use [option {--branch NAME_OF_NEW_BRANCH}] and
       then have to correct that oversight via the fossil web
       interface (I am currently unaware of ways of doing such from
       the command line, although some magic incantantion of
       [cmd {fossil tag create}] may work).

[para] It helps to keep awareness, like checking before any commit
       that we are on the desired branch.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






















































































































Deleted devdoc/parts/d_op_clean.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Be aware of where you are (see first definition).

[para] For pretty much all the operation recipes below a clean
       checkout is at least desired, often required.
       To check that a checkout is clean invoke

[example {
    fossil changes
    fossil extra
}]

How to clean up when uncommitted changes of all sorts are found is
context-specific and outside of the scope of this guide.
<
<
<
<
<
<
<
<
<
<
<
<
<
<




























Deleted devdoc/parts/d_testing.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

Testsuites in Tcllib are based on Tcl's standard test package
[package tcltest], plus utilities found in the directory
[file modules/devtools]

[para] Tcllib developers invoke the suites through the
[cmd {test run}] method of the [file sak.tcl] tool, with other methods
of [cmd test] providing management operations, for example setting a
list of standard Tcl shells to use.

[comment {===================================================================}]
[subsection {Invoke the testsuites of a specific module}]

Invoke either

[example {  ./sak.tcl test run foo }]

or

[example {  ./sak.tcl test run modules/foo }]

to invoke the testsuites found in a specific module [file foo].

[comment {===================================================================}]
[subsection {Invoke the testsuites of all modules}]

Invoke the tool without a module name, i.e.

[example {  ./sak.tcl test run }]

to invoke the testsuites of all modules.

[comment {===================================================================}]
[subsection {Detailed Test Logs}]

In all the previous examples the test runner will write a combination
of progress display and testsuite log to the standard output, showing
for each module only the tests that passed or failed and how many of
each in a summary at the end.

[para] To get a detailed log, it is necessary to invoke the test
runner with additional options.

[para] For one:

[example {
   ./sak.tcl test run --log LOG foo
}]

While this shows the same short log on the terminal as before, it also
writes a detailed log to the file [file LOG.log], and excerpts to
other files ([file LOG.summary], [file LOG.failures], etc.).

[para] For two:

[example {
  ./sak.tcl test run -v foo
}]

This writes the detailed log to the standard output, instead of the
short log.

[para] Regardless of form, the detailed log contains a list of all test
cases executed, which failed, and how they failed (expected versus
actual results).

[comment {===================================================================}]
[subsection {Shell Selection}]

By default the test runner will use all the Tcl shells specified via
[cmd {test add}] to invoke the specified testsuites, if any. If no
such are specified it will fall back to the Tcl shell used to run the
tool itself.

[para] Use option [option --shell] to explicitly specify the Tcl shell
to use, like

[example {
  ./sak.tcl test run --shell /path/to/tclsh ...
}]

[comment {===================================================================}]
[subsection Help]

Invoke the tool as

[example {  ./sak.tcl help test }]

to see the detailed help for all methods of [cmd test], and the
associated options.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































Deleted devdoc/parts/d_testwrite.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

While previous sections talked about running the testsuites for a
module and the packages therein, this has no meaning if the module in
question has no testsuites at all.

[para] This section gives a very basic overview on possible
methodologies for writing tests and testsuites.

[para] First there are "drudgery" tests. Written to check absolutely
basic assumptions which should never fail.

[para] For example for a command FOO taking two arguments, three tests
calling it with zero, one, and three arguments. The basic checks that
the command fails if it has not enough arguments, or too many.

[para] After that come the tests checking things based on our
knowledge of the command, about its properties and assumptions. Some
examples based on the graph operations added during Google's Summer of
Code 2009 are:

[list_begin itemized]

[item]	The BellmanFord command in struct::graph::ops takes a
	[arg startnode] as argument, and this node should be a node of
	the graph. This equals one test case checking the behavior when the
	specified node is not a node of the graph.

[para]  This often gives rise to code in the implementation which
	explicitly checks the assumption and throws an understandable error,
	instead of letting the algorithm fail later in some weird
	non-deterministic way.

[para]  It is not always possible to do such checks. The graph argument
	for example is just a command in itself, and while we expect
	it to exhibit a certain interface, i.e. a set of sub-commands
	aka methods, we cannot check that it has them, except by
	actually trying to use them. That is done by the algorithm
	anyway, so an explicit check is just overhead we can get by
	without.

[item]  IIRC one of the distinguishing characteristic of either
	BellmanFord and/or Johnson is that they are able to handle
	negative weights. Whereas Dijkstra requires positive weights.

[para]	This induces (at least) three testcases ... Graph with all
	positive weights, all negative, and a mix of positive and
	negative weights.

	Thinking further does the algorithm handle the weight
	[const 0] as well ? Another test case, or several, if we mix
	zero with positive and negative weights.

[item]	The two algorithms we are currently thinking about are about
	distances between nodes, and distance can be 'Inf'inity,
	i.e. nodes may not be connected. This means that good test
	cases are

	[list_begin enumerated]
	[enum]	Strongly connected graph
	[enum]	Connected graph
	[enum]	Disconnected graph.
	[list_end]

	[para] At the extremes of strongly connected and disconnected
	we have the fully connected graphs and graphs without edges,
	only nodes, i.e. completely disconnected.

[item]	IIRC both of the algorithms take weighted arcs, and fill in a
	default if arcs are left unweighted in the input graph.

	[para] This also induces three test cases:

	[list_begin enumerated]
	[enum]	Graph will all arcs with explicit weights.
	[enum]	Graph without weights at all.
	[enum]	Graph with mixture of weighted and unweighted graphs.
	[list_end]
[list_end]

[para] What was described above via examples is called
[term black-box] testing. Test cases are designed and written based on
the developer's knowledge of the properties of the algorithm and its
inputs, without referencing a particular implementation.

[para] Going further, a complement to [term black-box] testing is
[term white-box]. For this we know the implementation of the
algorithm, we look at it and design our tests cases so that they force
the code through all possible paths in the implementation. Wherever a
decision is made we have a test case forcing a specific direction of
the decision, for all possible combinations and directions. It is easy
to get a combinatorial explosion in the number of needed test-cases.

[para] In practice I often hope that the black-box tests I have made
are enough to cover all the paths, obviating the need for white-box
tests.

[para] The above should be enough to make it clear that writing tests
for an algorithm takes at least as much time as coding the algorithm,
and often more time. Much more time.

See for example also [uri http://sqlite.org/testing.html], a writeup
on how the Sqlite database engine is tested. Another article of
interest might be [uri https://www.researchgate.net/publication/298896236].
While geared to a particular numerical algorithm it still shows that
even a simple-looking algorithm can lead to an incredible number of
test cases.

[para] An interesting connection is to documentation. In one
direction, the properties checked with black-box testing are exactly
the properties which should be documented in the algorithm's man
page. And conversely, the documentation of the properties of an
algorithm makes a good reference to base the black-box tests on.

[para] In practice test cases and documentation often get written
together, cross-influencing each other. And the actual writing of test
cases is a mix of black and white box, possibly influencing the
implementation while writing the tests. Like writing a test for a
condition like [term {startnode not in input graph}] serving as
reminder to put a check for this condition into the code.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<














































































































































































































































Deleted devdoc/parts/rm_distribute.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

With the release made it has to be published and the world notified of
its existence.

[list_begin enumerated]

[enum]	    Create a proper fossil event for the release, via
	    [uri http://core.tcl-lang.org/tcllib/eventedit].

[para]	    An [uri http://core.tcl-lang.org/tcllib/event/dac0ddcd2e990234143196b4dc438fe01e7b9817 {existing event}] should be used as template.

[enum]	    Update a number of web locations:

[list_begin enumerated]
[enum]	    [uri http://core.tcl-lang.org/tcllib/doc/trunk/embedded/index.md {Home page}]
[enum]	    [uri http://core.tcl-lang.org/tcllib/wiki?name=Downloads     Downloads]
[enum]	    [uri http://core.tcl-lang.org/tcllib/wiki?name=Past+Releases {Past Releases}]
[enum]	    [uri http://www.tcl-lang.org/home/release.txt     ]
[enum]	    [uri http://www.tcl-lang.org/software/tcllib/*.tml]
[enum]	    [uri http://wiki.tcl-lang.org/page/Tcllib]
[list_end]

The first location maps to the file [file embedded/index.md] in the
repository itself, as such it can edited as part of the release
process. This is where reference to the new fossil event is added, as
the new current release.

[para] The next two locations are in the fossil tcllib wiki and
require admin or wiki write permissions for
[uri http://core.tcl-lang.org/tcllib].

[para] The last two locations require ssh access to
[uri http://www.tcl-lang.org] and permission to edit
files in the web area.


[enum]	***TODO*** mailing lists and other places to send notes to.

[list_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<














































































Deleted devdoc/parts/rm_final.inc.

1
todo: finalize release, make candidate official
<


Deleted devdoc/parts/rm_start.inc.

1
todo: open a candidate for release
<


Deleted devdoc/parts/rm_tooling.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

The [file sak.tcl] script in the toplevel directory of a Tcllib
checkout is the one tool used by the release manager to perform its
[sectref Tasks].

[para] The main commands to be used are

[example {
    sak.tcl validate
    sak.tcl test run
    sak.tcl review
    sak.tcl readme
    sak.tcl localdoc
    sak.tcl release
}]

More detail will be provided in the explanations of the various
[sectref Tasks].
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































Deleted devdoc/parts/rm_work.inc.

1
2
3
4
5
6
7
todo: test, validate and check that the candidate is worthy of release
fix testsuites, possibly fix packages, documentation
regenerate docs
coordinate with package maintainers wrt fixes

big thing: going over the packages, classify changes since last
release to generate a nice readme.
<
<
<
<
<
<
<














Deleted devdoc/parts/rq_critcl.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

[subsection Critcl]

The [syscmd critcl] tool is an [emph optional] dependency.

[para] It is only required when trying to build the C-based
[term accelerators] for a number of packages, as explained in
[sectref {Critcl & Accelerators}]

[para] Tcllib's build system looks for it in the [variable PATH],
using the name [syscmd critcl]. This is for Unix.

On Windows on the other hand the search is more complex. First we look
for a proper application [syscmd critcl.exe]. When that is not found
we look for a combination of interpreter ([syscmd tclkitsh.exe],
[syscmd tclsh.exe]) and starkit ([syscmd critcl.kit], [syscmd critcl])
instead. [emph Note] that the choice of starkit can be overriden via
the environment variable [variable CRITCL].

[para] Tcllib requires Critcl version 2 or higher.

[para] The github repository providing releases of version 2 and
higher, and the associated sources, can be found at
[uri http://andreas-kupries.github.com/critcl].

[para] Any branch of the repository can be used (if not using the
prebuild starkit or starpack), although the use of the stable branch
[emph master] is recommended.

[para] At the above url is also an explanation on how to build and
install Critcl, including a list of its dependencies.

[para] Its instructions will not be repeated here. If there are
problems with these directions please file a ticket against the
[term Critcl] project, and not Tcllib.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






































































Deleted devdoc/parts/rq_tcl.inc.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

[subsection Tcl]

As we are installing a number of Tcl packages and applications it
should be pretty much obvious that a working installation of Tcl
itself is needed, and I will not belabor the point.

[para] Out of the many possibilities use whatever you are comfortable
with, as long as it provides at the very least Tcl 8.2, or higher.

This may be a Tcl installation provided by your operating system
distribution, from a distribution-independent vendor, or built by
yourself.

[para] [emph Note] that the packages in Tcllib have begun to require
8.4, 8.5, and even 8.6. Older versions of Tcl will not be able to use
such packages. Trying to use them will result in
[emph {package not found}] errors, as their package index files will
not register them in versions of the core unable to use them.

[para] Myself, I used (and still use)
[uri http://www.activestate.com ActiveState's]
ActiveTcl 8.5 distribution during development, as I am most familiar
with it.

[para] [emph {(Disclosure: I, Andreas Kupries, worked for ActiveState until 2016, maintaining ActiveTcl and TclDevKit for them).}].
I am currently working for SUSE Software Canada ULC, although not in
Tcl-related areas.

[para] This distribution can be found at
[uri http://www.activestate.com/activetcl]. Retrieve the archive of
ActiveTcl 8.5 (or higher) for your platform and install it as directed
by ActiveState.

[para] For those wishing to build and install Tcl on their own, the
relevant sources can be found at

[list_begin definitions]
[def Tcl] [uri http://core.tcl-lang.org/tcl/]
[list_end]

together with the necessary instructions on how to build it.

[para] If there are problems with building, installing, or using Tcl,
please file a ticket against [term Tcl], or the vendor of your
distribution, and [emph not] [term Tcllib].
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




























































































Deleted devdoc/parts/welcome.inc.

1
2
3
4
5
6

Welcome to Tcllib, the Tcl Standard Library. Note that Tcllib is not a
package itself. It is a collection of (semi-independent) [term Tcl]
packages that provide utility functions useful to a large collection
of Tcl programmers.

<
<
<
<
<
<












Added devdoc/releaseguide.html.

















































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<!- Guide to the creation of source releases for Tcllib -->

<h1>Guide to the creation of source releases for Tcllib
</h1>
<hr>

<h2>Recap
</h2>
<table><tr><td valign=top>
      <!-- The local source of this image is
		tcllib/devel/cvs.branches.*
	-->
      <img src="http://sourceforge.net/dbimage.php?id=2221">
</td><td valign=top><p>
The CVS repository for Tcllib contains two main branches,
      the HEAD for development, and RELEASES as the staging area for
      official releases.
</p></td></tr></table>

<h2>Dependencies
</h2>

<h2>Creation of a new official release
</h2>

<p>To create a new official release of Tcllib the release manager has
      to perform the steps described below:
</p>


<ol>
<li> Retrieve the sources at the current head
	from the CVS repository, using a command like
<pre>
	  CVSROOT=:pserver:anonymous@cvs.tcllib.sourceforge.net:/cvsroot/tcllib
	  cvs -d${CVSROOT} co tcllib
</pre>
	Vary this command according to taste as long as the overall
	meaning is not changed. Compression options and the like.

<li> Tag these sources with a new branch tag for the new release of
	  tcllib, like
<pre>
	  cvs -d${CVSROOT} rtag tcllib
</pre>

<li> Commit the changes, then update the working directory.

<li> Use a tclsh to run the <b>sak</b> tool with the argument <i>gendist</i>, like
<pre>
    tclsh /path/to/tcllib/sak.tcl gendist
</pre>

<li> This results in the creation of a <i>tcllib-VERSION</i> directory
in the current working directory, and of two archives, <i>.zip</i>,
and <i>.tar.gz</i>. A starkit will be created if <b>sdx</b> is present
in the PATH. If additionally a file named <b>tclkit</b> is present in
the current working directory a starpack will be created too, using
this tclkit as the runtime.


<li> Now follow the instructions in the Sourceforge site documentation
		    for uploading the archives generated by the last
		    step to
		    <b>ftp://upload.sourceforge.net/incoming</b>, and
		    follow the procedures for creating packages and
		    releases at Sourceforge.
</ol>

<p>At last notify the relevant persons in other communities like
Debian (See list of contacts) about the new release.
</p>

Deleted devdoc/tcl_community_communication.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcl_community_communication n 1]
[titledesc {Tcl Community - Kind Communication}]
[description]

The Tcl Community encourages contributions from anyone who wishes to
advance the development of:

[list_begin itemized]
[item] The Tcl Language
[item] Tcl derived languages
[item] Tcl related libraries
[item] Tcl extensions
[item] External Projects that Integrate Tcl
[list_end]

[para] We welcome those contributions from anyone. We are blind to
gender, race, religion, cultural background, cybernetic nature, and
any other demographic characteristics, as well as personal political
views.

[para] A community lives and dies by communications. And occasionally
our communications are peppered with patterns that are harsh,
unfriendly, unwelcoming and/or otherwise unkind. As a volunteer
community, we need all of the help we can get. Therefore, we ask all
contributors to make a conscious effort, in Tcl Community discussions,
to communicate in ways that are welcoming. Ways that are
friendly. Ways that are, in a word: kind.

[para] These guidelines suggest specific ways to accomplish that goal.

[para] Please note: for the balance of this document any reference to
"People", "Persons", "anybody" or "somebody" can refer to any sentient
being, not merely corporeal members of the species Homo Sapien.

[list_begin definitions]

[def {We are a Sanctuary not a Clubhouse}]

The Tcl Community is a collective of amateurs and professionals who
code, test, and use tools. Our community is open to all. There is no
velvet rope. There is no bouncer at the door. There are no secret
handshakes. Any sentient being who enters our midst is welcome. If
someone is ever asked to leave, it is only because they are being
disruptive to the functioning of the community.

[def {We Merit Ideas, Not People}]

A good idea can come from anyone, regardless of how little time they
have been with us. A bad idea can come from anyone, regardless of how
much time or how little time they have been with us. We judge a
concept by how it stands up to scrutiny of logic, implementation, and
regression testing. We don’t judge ideas based on who had the idea
first, who agrees with the idea, or who disagrees with it.

[def {Treat Everyone with Respect}]

Everyone is deserving of respect and courtesy at all times.

[def {Refer to people by the names they use.}]

If grammar requires you to state a gender for a person, honor their
preferences about their gender identity. If you are unsure as to the
gender of an individual, ask. If someone had to guess about your
gender and got it wrong, please correct them and do not take it
personally.

[def {Do not take a harsh tone towards other participants.}]

Do not make personal attacks against anyone (participant or not.)

[para] Criticize statements and actions, never people.

[def {Don’t Take Things Personally}]

When in doubt, assume the best in people. A criticism of your
statements is not a personal attack on you.

[def {Persons, not People}]

Stereotypes are an unhelpful tool on many accounts. They are generally
oversimplified. They are usually flat out wrong. And even if "right"
they are of absolutely no utility in determining the capabilities,
motivations, or fitness of an individual.

[para] Don’t use them in Tcl Community communications.

[def {Mistakes Happen}]

The human condition is a series of trials and errors. Progress is when
we get one more trial than error. Being wrong or making a mistake is
the default state of humanity. Accept the errors of your fellow
sentient beings, and be aware that you are also fallible.

[def {Keep it Real}]

Please respond to what people actually say. We are all amazing
individuals, but none among us are mind readers. If you find yourself
responding to what you imagine someone is thinking, odds are you are
going to be wrong.

[para] If you must criticize someone, stick to things they have
actually done. Never criticize for something you speculate they have
done. Or imagine they have done. Or something someone who shares some
attribute with them has done in the past.

[para] Keep discussions about any non-Tcl subjects to what can be
stated factually and without emotion or judgement.

[def {When Trouble Arises, Don’t Escalate}]

If you feel you are being personally attacked or offended, take the
high road. Punching back in a public forum will only makes things
worse. Address the matter in a private correspondence. Be
polite. Express your feelings, but note that you are expressing your
feelings. When writing, look for a way to calm matters down. And when
in doubt, sleep on your letter before pressing send. And when not in
doubt, sleep on it for another day after that.

[para] If you are a spectator to a fight in progress, politely request
the two parties take the matter to a more private forum.

[def {Always get the Last Word: I’m Sorry}]

If an personal argument does arise, be the first to apologize. An
apology does not concede a logical point. It merely acknowledges that
at some point the discussion left either logic, community decency, or
both. Return to the topic when cooler heads can prevail.

[def {Nobody is Keeping Score}]

There is no prize for being right. There is no cost for being wrong. A
hard sell is not going to advance your idea along any more than a
logical argument. You aren’t running for office. This isn’t debate
club. If you find yourself continuing a discussion beyond where a
topic can be logically discussed, stop.

[def {No Evangelizing}]

The Tcl Community is not the place to promote your chosen operating
system, political outlook, religion, marketing scheme, or economic
model. Period.

[para] (And if you do bring it up, be prepared to have your chosen
topic discussed logically. And odds are, not favorably.)

[def {Respect the Community}]

If the Community has come to a decision on a course of action, please
stop arguing.

[para] If someone complains about how you are expressing your ideas,
listen.

[para] If your words are hurting people, stop. There is no amount of
being "right" that makes up for someone leaving our midst because they
felt insulted, threatened, or ignored.

[list_end]

By following these guidelines, we will build our community, encourage
more contribution to our projects, and our discussions will be
friendlier and reach conclusions more easily.

[para] Thank You.

[section Signatories]
[list_begin itemized]
[item] Sean "the Hypnotoad" Woods
[item] Andreas Kupries
[list_end]

[section Authors]
[list_begin definitions]
[def Primary] Sean "the Hypnotoad" Woods
[def {Light editing}] Andreas Kupries
[list_end]
[manpage_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































































































































































































































































































































































Deleted devdoc/tcllib_devguide.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcllib_devguide n 1]
[titledesc {Tcllib - The Developer's Guide}]
[description]
[include parts/welcome.inc]

[para]

This document is a guide for developers working on Tcllib,
i.e. maintainers fixing bugs, extending the collection's
functionality, etc.

[para]

Please read

[list_begin enum]
[enum] [term {Tcllib - How To Get The Sources}] and
[enum] [term {Tcllib - The Installer's Guide}]
[list_end]

first, if that was not done already.

[para] Here we assume that the sources are already available in a
directory of your choice, and that you not only know how to build and
install them, but also have all the necessary requisites to actually
do so. The guide to the sources in particular also explains which
source code management system is used, where to find it, how to set it
up, etc.

[comment {===================================================================}]
[section Commitments]
[subsection Contributor][include parts/d_contrib.inc]
[subsection Maintainer][include parts/d_maintain.inc]

[comment {===================================================================}]
[section {Branching and Workflow}]
[include parts/d_branchflow.inc]

[comment {===================================================================}]
[section {Structural Overview}]
[include parts/d_dirlayout.inc]

[comment {===================================================================}]
[section {Testsuite Tooling}]
[include parts/d_testing.inc]

[comment {===================================================================}]
[section {Documentation Tooling}]
[include parts/d_documentation.inc]

[comment {===================================================================}]
[section {Notes On Writing A Testsuite}]
[include parts/d_testwrite.inc]

[comment {===================================================================}]
[section {Installation Tooling}]
[include parts/d_installation.inc]

[comment {===================================================================}]
[manpage_end]

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




























































































































Deleted devdoc/tcllib_installer.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcllib_install_guide n 1]
[titledesc {Tcllib - The Installer's Guide}]
[description]
[include parts/welcome.inc]

[para]

The audience of this document is anyone wishing to build and install
the packages found in Tcllib, for either themselves, or others.

[para]

For developers intending to work on the packages themselves we
additionally provide

[list_begin enum]
[enum] [term {Tcllib - The Developer's Guide}].
[list_end]

[para]

Please read [term {Tcllib - How To Get The Sources}] first, if that
was not done already. Here we assume that the sources are already
available in a directory of your choice.

[para]

[comment {===================================================================}]
[section Requisites]

Before Tcllib can be build and used a number of requisites must be installed.

These are:

[list_begin enumerated]
[enum] The scripting language Tcl.
       For details see [sectref Tcl].
[enum] Optionally, the [package critcl] package (C embedding) for [syscmd Tcl].
       For details see [sectref CriTcl].
[list_end]

This list assumes that the machine where Tcllib is to be installed is
essentially clean. Of course, if parts of the dependencies listed
below are already installed the associated steps can be skipped. It is
still recommended to read their sections though, to validate that the
dependencies they talk about are indeed installed.

[include parts/rq_tcl.inc]
[include parts/rq_critcl.inc]

[comment {= build instructions ==============================================}]
[section {Build & Installation Instructions}]

As Tcllib is mainly a bundle of packages written in pure Tcl building
it is the same as installing it. The exceptions to this have their own
subsection, [sectref {Critcl & Accelerators}], later on.

[para] Before that however comes the standard case, differentiated by
       the platforms with material differences in the instruction, i.e.
       [term Unix]-like, versus [term Windows].

[para] Regarding the latter it should also be noted that it is
       possible set up an [term Unix]-like environment using projects
       like [term MSYS], [term Cygwin], and others. In that case the
       user has the choice of which instructions to follow.

[para] Regardless of environment or platform, a suitable [term Tcl]
       has to be installed, and its [syscmd tclsh] should be placed on
       the [variable PATH] ([term Unix]) or associated with
       [file .tcl] files ([term Windows]).

[comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%]
[subsection {Installing on Unix}]
[include parts/b_unix.inc]

[comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%]
[subsection {Installing on Windows}]
[include parts/b_windows.inc]

[comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%]
[subsection {Critcl & Accelerators}]
[include parts/b_critcl.inc]

[comment %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%]
[subsection Tooling]
[include parts/b_tooling.inc]

[manpage_end]

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































Deleted devdoc/tcllib_license.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcllib_license n 1]
[titledesc {Tcllib - License}]
[description]
[include parts/welcome.inc]

[para] The collection is under the BSD license.

[section License]

[para]

This software is copyrighted by Ajuba Solutions and other parties.
The following terms apply to all files associated with the software
unless explicitly disclaimed in individual files.

[para]

The authors hereby grant permission to use, copy, modify, distribute,
and license this software and its documentation for any purpose,
provided that existing copyright notices are retained in all copies
and that this notice is included verbatim in any distributions. No
written agreement, license, or royalty fee is required for any of the
authorized uses.  Modifications to this software may be copyrighted by
their authors and need not follow the licensing terms described here,
provided that the new terms are clearly indicated on the first page of
each file where they apply.

[para]

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

[para]

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, AND
THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

[para]

GOVERNMENT USE: If you are acquiring this software on behalf of the
U.S. government, the Government shall have only "Restricted Rights" in
the software and related documentation as defined in the Federal
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2).  If you
are acquiring the software on behalf of the Department of Defense, the
software shall be classified as "Commercial Computer Software" and the
Government shall have only "Restricted Rights" as defined in Clause
252.227-7013 (c) (1) of DFARs.  Notwithstanding the foregoing, the
authors grant the U.S. Government and others acting in its behalf
permission to use and distribute the software in accordance with the
terms specified in this license.

[manpage_end]

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































Deleted devdoc/tcllib_releasemgr.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcllib_releasemgr n 1]
[titledesc {Tcllib - The Release Manager's Guide}]
[description]
[include parts/welcome.inc]

[para]

The audience of this document is the release manager for Tcllib, their
deputies, and anybody else interested in the task of creating
an official release of Tcllib for distribution.

[para]

Please read [term {Tcllib - How To Get The Sources}] first, if that
was not done already. Here we assume that the sources are already
available in a directory of your choice.

[para]

[comment {===================================================================}]
[section Tools]
[include parts/rm_tooling.inc]

[comment {===================================================================}]
[section Tasks]

[comment {===================================================================}]
[subsection {Start a release candidate}]
[include parts/rm_start.inc]

[comment {===================================================================}]
[subsection {Ready the candidate}]
[include parts/rm_work.inc]

[comment {===================================================================}]
[subsection {Make it official}]
[include parts/rm_final.inc]

[comment {===================================================================}]
[subsection {Distribute the release}]
[include parts/rm_distribute.inc]

[manpage_end]

<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































Deleted devdoc/tcllib_sources.man.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
[comment {-*- tcl -*- doctools manpage}]
[manpage_begin tcllib_sources n 1]
[titledesc {Tcllib - How To Get The Sources}]
[description]
[include parts/welcome.inc]

[para]

The audience of this document is anyone wishing to either have just a
look at Tcllib's source code, or build the packages, or to extend and
modify them.

[para] For builders and developers we additionally provide

[list_begin enum]
[enum] [term {Tcllib - The Installer's Guide}].
[enum] [term {Tcllib - The Developer's Guide}].
[list_end]

respectively.

[section {Source Location}]

The official repository for Tcllib can be found at
[uri http://core.tcl-lang.org/tcllib]

[section Retrieval]

Assuming that you simply wish to look at the sources, or build a
specific revision, the easiest way of retrieving it is to:

[list_begin enum]
[enum] Log into this site, as "anonymous", using the semi-random password in the captcha.
[enum] Go to the "Timeline".
[enum] Choose the revision you wish to have.
[enum] Follow its link to its detailed information page.
[enum] On that page, choose either the "ZIP" or "Tarball" link to get
a copy of this revision in the format of your choice.
[list_end]

[section {Source Code Management}]

For the curious (or a developer-to-be), the sources are managed by the
[uri http://www.fossil-scm.org {Fossil SCM}].

Binaries for popular platforms can be found directly at its
[uri http://www.fossil-scm.org/download.html {download page}].

[para]

With that tool available the full history can be retrieved via:

[example {
    fossil clone \
	http://core.tcl-lang.org/tcllib \
        tcllib.fossil
}]

followed by

[example {
    mkdir tcllib
    cd tcllib
    fossil open ../tcllib.fossil
}]

to get a checkout of the head of the trunk.

[manpage_end]
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































Added embedded/index.html.























































































































































>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
<div class='fossil-doc' data-title='Tcl Library Source Code'>

<h1 align="center">Tcl Library Source Code</h1>

<center>
<form action='../../../docsrch' method='GET'>
<input type="text" name="s" size="40" autofocus>
<input type="submit" value="Search Docs">
</form>
<p><a href="www/toc.html">
Table Of Contents</a>
&nbsp;&nbsp;&nbsp;
<a href="www/index.html">
Keyword Index</a>
</center>

<h2>Discussion &amp; Contact</h2>
<ul>
<p>Tcllib has two <a href="https://sourceforge.net/p/tcllib/mailman/">mailing lists</a>,
one for notifications, the other for general discussion. These are managed at SourceForge,
at the aforementioned link. A few direct links for various topics:
<table>
<tr><td>tcllib-bugs: </td>
<td><a href="https://lists.sourceforge.net/lists/listinfo/tcllib-bugs">Subscribe</a></td>
<td><a href="https://sourceforge.net/p/tcllib/mailman/tcllib-bugs">Archive</a></td>
<td><a href="https://sourceforge.net/p/tcllib/mailman/search/?mail_list=tcllib-bugs">Search</a></td></tr>
<tr><td>tcllib-devel:</td>
<td><a href="https://lists.sourceforge.net/lists/listinfo/tcllib-devel">Subscribe</a></td>
<td><a href="https://sourceforge.net/p/tcllib/mailman/tcllib-devel">Archive</a></td>
<td><a href="https://sourceforge.net/p/tcllib/mailman/search/?mail_list=tcllib-devel">Search</a></td></tr>
</table>

</ul></p>
</ul>

<h2>Feedback</h2>
<ul>
<p>Please go to and use our
<a href="../../../reportlist">
Local Trackers</a>. They are for
<ul>
<li>Bugs,</li>
<li>Patches, and </li>
<li>Ideas &amp; Feature Requests.</li>
</ul></p>
</ul>

<h2>Releases</h2>

<ul>
<p>Current:
<b>1.18 (Feb 3, 2016)</b>
<a href="../../../technote/0bcd06266284a9997e69001e245ecc231a2a4ebd">Details</a>

</p>
<p><a href='../../../wiki?name=Past+Releases'>[Past Releases]</a></p>
<p><a href='../../../wiki?name=Development+Snapshots'>[Development Snapshots]</a></p>
<p><a href="https://sourceforge.net/projects/tcllib/files/">@ SourceForge</a></p>
</ul>

<h2>Related Repositories</h2>
<ul>
<li><a href="../../../../tklib">Tklib</a></li>
<li><a href="../../../../tclapps">Tcl Apps</a></li>
<li><a href="../../../../tclbench">Tcl Bench</a></li>
<li><a href="../../../../mclistbox">Multicolumn Listbox</a></li>
<li><a href="../../../../widget">Widget</a></li>
<li><a href="../../../../bwidget">BWidget</a></li>
</ul>


<h2>See also</h2>
<ul>
<li><a href="http://www.tcl.tk/software/tcllib/">Landing page for this package at the Tcl Developer eXchange</a></li>
</ul>

Deleted embedded/index.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<div class='fossil-doc' data-title='Tcl Library Source Code'>

<h1 align="center">Tcl Library Source Code</h1>

<center>
Packages - [Table Of Contents](md/toc.md)
&nbsp;&nbsp;&nbsp;
[Keyword Index](md/index.md)
</center>

<center>
	<form action='../../../docsrch' method='GET'>
	<input type="text" name="s" size="40" autofocus>
	<input type="submit" value="Search Package Documentation">
	</form>
</center>

## Guides to Tcllib

   * [Tcl Community - Kind Communication](md/tcllib/files/devdoc/tcl_community_communication.md)
   * [License](md/tcllib/files/devdoc/tcllib_license.md)
   * [How To Get The Sources](md/tcllib/files/devdoc/tcllib_sources.md)
   * [How To Build And Install Tcllib](md/tcllib/files/devdoc/tcllib_installer.md)
   * [The Developer's Guide](md/tcllib/files/devdoc/tcllib_devguide.md)
   * [The Release Manager's Guide](md/tcllib/files/devdoc/tcllib_releasemgr.md)

## Discussion & Contact

Tcllib has two
[mailing lists](https://sourceforge.net/p/tcllib/mailman/).

One for notifications (commits, ticket changes), the other for general
discussion. These are managed at SourceForge, at the aforementioned
link. A few direct links for various topics:

|tcllib-bugs| : |[Subscribe](https://lists.sourceforge.net/lists/listinfo/tcllib-bugs) [Archive](https://sourceforge.net/p/tcllib/mailman/tcllib-bugs) [Search](https://sourceforge.net/p/tcllib/mailman/search/?mail_list=tcllib-bugs)|
|tcllib-devel| : |[Subscribe](https://lists.sourceforge.net/lists/listinfo/tcllib-devel) [Archive](https://sourceforge.net/p/tcllib/mailman/tcllib-devel) [Search](https://sourceforge.net/p/tcllib/mailman/search/?mail_list=tcllib-devel)|

## Feedback

Please go to and use our
[Local Trackers](../../../reportlist).
They are for

   * Bugs,
   * Patches, and	 
   * Ideas & Feature Requests.

## Releases

   * [Current](../../../technote/cd3a11c3065120d491009e64a19f7676176045cd) __1.20 (Dec 1, 2019)__
   * [Past Releases](../../../wiki?name=Past+Releases)
   * [Development Snapshots](../../../wiki?name=Development+Snapshots)
   * [@ SourceForge](https://sourceforge.net/projects/tcllib/files/)

## Related Repositories

   * [Tklib](../../../../tklib)
   * [Tcl Apps](../../../../tclapps)
   * [Tcl Bench](../../../../tclbench)
   * [Multicolumn Listbox](../../../../mclistbox)
   * [Widget](../../../../widget)
   * [BWidget](../../../../bwidget)


## See also

   * [Landing page for this package at the Tcl Developer eXchange](http://www.tcl.tk/software/tcllib/)
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<








































































































































Deleted embedded/md/image/arch_core_container.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_eplugins.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_export.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_import.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_iplugins.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_support.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_core_transform.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_user_app.png.

cannot compute difference between binary files

Deleted embedded/md/image/arch_user_pkg.png.

cannot compute difference between binary files

Deleted embedded/md/image/architecture.png.

cannot compute difference between binary files

Deleted embedded/md/image/expr_ast.png.

cannot compute difference between binary files

Deleted embedded/md/image/flow.png.

cannot compute difference between binary files

Deleted embedded/md/image/gen_options.png.

cannot compute difference between binary files

Deleted embedded/md/index.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034

[//000000001]: # (Index generated by tcllib/doctools/idx with format 'markdown')

# Keyword Index

----

[3](#c3) &#183; [A](#cA) &#183; [B](#cB) &#183; [C](#cC) &#183; [D](#cD) &#183; [E](#cE) &#183; [F](#cF) &#183; [G](#cG) &#183; [H](#cH) &#183; [I](#cI) &#183; [J](#cJ) &#183; [K](#cK) &#183; [L](#cL) &#183; [M](#cM) &#183; [N](#cN) &#183; [O](#cO) &#183; [P](#cP) &#183; [Q](#cQ) &#183; [R](#cR) &#183; [S](#cS) &#183; [T](#cT) &#183; [U](#cU) &#183; [V](#cV) &#183; [W](#cW) &#183; [X](#cX) &#183; [Y](#cY) &#183; [Z](#cZ)

----

#### <a name='c3'></a>Keywords: 3

|||
|---|---|
|<a name='3des'></a>3DES|[des](tcllib/files/modules/des/des\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|


#### <a name='cA'></a>Keywords: A

|||
|---|---|
|<a name='abstract\_syntax\_tree'></a>abstract syntax tree|[grammar::me::util](tcllib/files/modules/grammar\_me/me\_util\.md) &#183; [grammar::me\_ast](tcllib/files/modules/grammar\_me/me\_ast\.md)|
|<a name='acceptance'></a>acceptance|[grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md)|
|<a name='acceptor'></a>acceptor|[grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md)|
|<a name='active'></a>active|[transfer::connect](tcllib/files/modules/transfer/connect\.md)|
|<a name='adaptors'></a>adaptors|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|
|<a name='adjacency\_list'></a>adjacency list|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='adjacency\_matrix'></a>adjacency matrix|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='adjacent'></a>adjacent|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='adjusting'></a>adjusting|[textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|
|<a name='adler32'></a>adler32|[tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md)|
|<a name='aes'></a>aes|[aes](tcllib/files/modules/aes/aes\.md)|
|<a name='after'></a>after|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='alias'></a>alias|[interp](tcllib/files/modules/interp/tcllib\_interp\.md)|
|<a name='amazon'></a>amazon|[S3](tcllib/files/modules/amazon\-s3/S3\.md)|
|<a name='ambiguous'></a>ambiguous|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md)|
|<a name='american\_express'></a>American Express|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md)|
|<a name='amex'></a>AMEX|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md)|
|<a name='angle'></a>angle|[math::geometry](tcllib/files/modules/math/math\_geometry\.md) &#183; [units](tcllib/files/modules/units/units\.md)|
|<a name='anonymous\_procedure'></a>anonymous procedure|[lambda](tcllib/files/modules/lambda/lambda\.md)|
|<a name='ansi'></a>ansi|[term::ansi::code::attr](tcllib/files/modules/term/ansi\_cattr\.md) &#183; [term::ansi::code::ctrl](tcllib/files/modules/term/ansi\_cctrl\.md) &#183; [term::ansi::code::macros](tcllib/files/modules/term/ansi\_cmacros\.md) &#183; [term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='appender'></a>appender|[logger::appender](tcllib/files/modules/log/loggerAppender\.md) &#183; [logger::utils](tcllib/files/modules/log/loggerUtils\.md)|
|<a name='application'></a>application|[nns](tcllib/files/apps/nns\.md) &#183; [nnsd](tcllib/files/apps/nnsd\.md) &#183; [nnslog](tcllib/files/apps/nnslog\.md)|
|<a name='approximation\_algorithm'></a>approximation algorithm|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='arc'></a>arc|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='arcfour'></a>arcfour|[rc4](tcllib/files/modules/rc4/rc4\.md)|
|<a name='archive'></a>archive|[tar](tcllib/files/modules/tar/tar\.md)|
|<a name='argument\_integrity'></a>argument integrity|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::procedure](tcllib/files/modules/tepam/tepam\_procedure\.md)|
|<a name='argument\_processing'></a>argument processing|[cmdline](tcllib/files/modules/cmdline/cmdline\.md)|
|<a name='argument\_validation'></a>argument validation|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::procedure](tcllib/files/modules/tepam/tepam\_procedure\.md)|
|<a name='arguments'></a>arguments|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::procedure](tcllib/files/modules/tepam/tepam\_procedure\.md)|
|<a name='argv'></a>argv|[cmdline](tcllib/files/modules/cmdline/cmdline\.md)|
|<a name='argv0'></a>argv0|[cmdline](tcllib/files/modules/cmdline/cmdline\.md)|
|<a name='array'></a>array|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='articulation\_point'></a>articulation point|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='ascii85'></a>ascii85|[ascii85](tcllib/files/modules/base64/ascii85\.md)|
|<a name='asn'></a>asn|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='assembler'></a>assembler|[grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md)|
|<a name='assert'></a>assert|[control](tcllib/files/modules/control/control\.md)|
|<a name='assign'></a>assign|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='ast'></a>AST|[grammar::me\_ast](tcllib/files/modules/grammar\_me/me\_ast\.md)|
|<a name='asynchronous'></a>asynchronous|[cache::async](tcllib/files/modules/cache/async\.md)|
|<a name='attribute\_control'></a>attribute control|[term::ansi::code::attr](tcllib/files/modules/term/ansi\_cattr\.md) &#183; [term::ansi::code::ctrl](tcllib/files/modules/term/ansi\_cctrl\.md)|
|<a name='augmenting\_network'></a>augmenting network|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='augmenting\_path'></a>augmenting path|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='authentication'></a>authentication|[autoproxy](tcllib/files/modules/http/autoproxy\.md) &#183; [SASL](tcllib/files/modules/sasl/sasl\.md) &#183; [SASL::NTLM](tcllib/files/modules/sasl/ntlm\.md) &#183; [SASL::SCRAM](tcllib/files/modules/sasl/scram\.md) &#183; [SASL::XGoogleToken](tcllib/files/modules/sasl/gtoken\.md)|
|<a name='automatic'></a>automatic|[nameserv::auto](tcllib/files/modules/nns/nns\_auto\.md)|
|<a name='automatic\_documentation'></a>automatic documentation|[tepam::doc\_gen](tcllib/files/modules/tepam/tepam\_doc\_gen\.md)|
|<a name='automaton'></a>automaton|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md)|
|<a name='aycock'></a>aycock|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md)|


#### <a name='cB'></a>Keywords: B

|||
|---|---|
|<a name='bank'></a>bank|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md)|
|<a name='base32'></a>base32|[base32](tcllib/files/modules/base32/base32\.md) &#183; [base32::core](tcllib/files/modules/base32/base32core\.md) &#183; [base32::hex](tcllib/files/modules/base32/base32hex\.md)|
|<a name='base64'></a>base64|[base64](tcllib/files/modules/base64/base64\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md)|
|<a name='bash'></a>bash|[string::token::shell](tcllib/files/modules/string/token\_shell\.md)|
|<a name='bee'></a>bee|[bee](tcllib/files/modules/bee/bee\.md)|
|<a name='bench\_language'></a>bench language|[bench\_intro](tcllib/files/modules/bench/bench\_intro\.md) &#183; [bench\_lang\_intro](tcllib/files/modules/bench/bench\_lang\_intro\.md) &#183; [bench\_lang\_spec](tcllib/files/modules/bench/bench\_lang\_spec\.md)|
|<a name='benchmark'></a>benchmark|[bench](tcllib/files/modules/bench/bench\.md) &#183; [bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::csv](tcllib/files/modules/bench/bench\_wcsv\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md) &#183; [bench\_intro](tcllib/files/modules/bench/bench\_intro\.md) &#183; [bench\_lang\_intro](tcllib/files/modules/bench/bench\_lang\_intro\.md) &#183; [bench\_lang\_spec](tcllib/files/modules/bench/bench\_lang\_spec\.md)|
|<a name='ber'></a>ber|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='bessel\_functions'></a>Bessel functions|[math::special](tcllib/files/modules/math/special\.md)|
|<a name='bfs'></a>bfs|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='bibliography'></a>bibliography|[bibtex](tcllib/files/modules/bibtex/bibtex\.md)|
|<a name='bibtex'></a>bibtex|[bibtex](tcllib/files/modules/bibtex/bibtex\.md)|
|<a name='bignums'></a>bignums|[math::bignum](tcllib/files/modules/math/bignum\.md)|
|<a name='bind'></a>bind|[uevent](tcllib/files/modules/uev/uevent\.md)|
|<a name='bipartite'></a>bipartite|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='bittorrent'></a>BitTorrent|[bee](tcllib/files/modules/bee/bee\.md)|
|<a name='bittorrent'></a>bittorrent|[bee](tcllib/files/modules/bee/bee\.md)|
|<a name='blanks'></a>blanks|[textutil::repeat](tcllib/files/modules/textutil/repeat\.md)|
|<a name='block\_cipher'></a>block cipher|[aes](tcllib/files/modules/aes/aes\.md) &#183; [blowfish](tcllib/files/modules/blowfish/blowfish\.md) &#183; [des](tcllib/files/modules/des/des\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|
|<a name='blocking\_flow'></a>blocking flow|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='blowfish'></a>blowfish|[blowfish](tcllib/files/modules/blowfish/blowfish\.md)|
|<a name='book\_number'></a>Book Number|[valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='breadth\_first'></a>breadth\-first|[struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='bridge'></a>bridge|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='bwidget'></a>BWidget|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|


#### <a name='cC'></a>Keywords: C

|||
|---|---|
|<a name='c'></a>C|[doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md)|
|<a name='c\_'></a>C\+\+|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md) &#183; [stooop](tcllib/files/modules/stooop/stooop\.md) &#183; [switched](tcllib/files/modules/stooop/switched\.md)|
|<a name='cache'></a>cache|[cache::async](tcllib/files/modules/cache/async\.md) &#183; [map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md)|
|<a name='caesar\_cipher'></a>caesar cipher|[tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md)|
|<a name='calculus'></a>calculus|[math::calculus](tcllib/files/modules/math/calculus\.md)|
|<a name='callback'></a>callback|[cache::async](tcllib/files/modules/cache/async\.md) &#183; [hook](tcllib/files/modules/hook/hook\.md) &#183; [lambda](tcllib/files/modules/lambda/lambda\.md) &#183; [oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md) &#183; [uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='callbacks'></a>callbacks|[tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md)|
|<a name='capitalize'></a>capitalize|[textutil::string](tcllib/files/modules/textutil/textutil\_string\.md)|
|<a name='card\_for\_credit'></a>card for credit|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md)|
|<a name='cardinality'></a>cardinality|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='cat'></a>cat|[fileutil](tcllib/files/modules/fileutil/fileutil\.md)|
|<a name='catalog\_package'></a>catalog package|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='catalogue'></a>catalogue|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md)|
|<a name='cell\_phone'></a>cell\-phone|[valtype::imei](tcllib/files/modules/valtype/imei\.md)|
|<a name='cer'></a>cer|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='cfg'></a>CFG|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md)|
|<a name='cfl'></a>CFL|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md)|
|<a name='cgi'></a>CGI|[ncgi](tcllib/files/modules/ncgi/ncgi\.md)|
|<a name='cgraph'></a>cgraph|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph\_v1](tcllib/files/modules/struct/graph1\.md)|
|<a name='changelog'></a>changelog|[doctools::changelog](tcllib/files/modules/doctools/changelog\.md) &#183; [doctools::cvs](tcllib/files/modules/doctools/cvs\.md)|
|<a name='channel'></a>channel|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md) &#183; [transfer::connect](tcllib/files/modules/transfer/connect\.md) &#183; [transfer::copy](tcllib/files/modules/transfer/copyops\.md) &#183; [transfer::copy::queue](tcllib/files/modules/transfer/tqueue\.md) &#183; [transfer::data::destination](tcllib/files/modules/transfer/ddest\.md) &#183; [transfer::data::source](tcllib/files/modules/transfer/dsource\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='channel\_transformation'></a>channel transformation|[tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md) &#183; [tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md) &#183; [tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md) &#183; [tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md) &#183; [tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md) &#183; [tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='character\_input'></a>character input|[term::receive](tcllib/files/modules/term/receive\.md) &#183; [term::receive::bind](tcllib/files/modules/term/term\_bind\.md)|
|<a name='character\_output'></a>character output|[term::ansi::send](tcllib/files/modules/term/ansi\_send\.md) &#183; [term::send](tcllib/files/modules/term/term\_send\.md)|
|<a name='chat'></a>chat|[irc](tcllib/files/modules/irc/irc\.md) &#183; [multiplexer](tcllib/files/modules/multiplexer/multiplexer\.md) &#183; [picoirc](tcllib/files/modules/irc/picoirc\.md)|
|<a name='checkbox'></a>checkbox|[html](tcllib/files/modules/html/html\.md) &#183; [javascript](tcllib/files/modules/javascript/javascript\.md)|
|<a name='checkbutton'></a>checkbutton|[html](tcllib/files/modules/html/html\.md)|
|<a name='checking'></a>Checking|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='checksum'></a>checksum|[cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md) &#183; [tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md)|
|<a name='chop'></a>chop|[textutil::string](tcllib/files/modules/textutil/textutil\_string\.md)|
|<a name='cipher'></a>cipher|[pki](tcllib/files/modules/pki/pki\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md)|
|<a name='cksum'></a>cksum|[cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md)|
|<a name='class'></a>class|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md) &#183; [stooop](tcllib/files/modules/stooop/stooop\.md) &#183; [switched](tcllib/files/modules/stooop/switched\.md)|
|<a name='class\_methods'></a>class methods|[oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='class\_variables'></a>class variables|[oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='cleanup'></a>cleanup|[defer](tcllib/files/modules/defer/defer\.md) &#183; [try](tcllib/files/modules/try/tcllib\_try\.md)|
|<a name='client'></a>client|[nameserv](tcllib/files/modules/nns/nns\_client\.md) &#183; [nameserv::auto](tcllib/files/modules/nns/nns\_auto\.md) &#183; [nameserv::common](tcllib/files/modules/nns/nns\_common\.md) &#183; [nns](tcllib/files/apps/nns\.md) &#183; [nns\_intro](tcllib/files/modules/nns/nns\_intro\.md) &#183; [nnslog](tcllib/files/apps/nnslog\.md)|
|<a name='cloud'></a>cloud|[S3](tcllib/files/modules/amazon\-s3/S3\.md)|
|<a name='cmdline\_processing'></a>cmdline processing|[cmdline](tcllib/files/modules/cmdline/cmdline\.md)|
|<a name='color\_control'></a>color control|[term::ansi::code::attr](tcllib/files/modules/term/ansi\_cattr\.md) &#183; [term::ansi::code::ctrl](tcllib/files/modules/term/ansi\_cctrl\.md)|
|<a name='columns'></a>columns|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='comm'></a>comm|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md) &#183; [deleg\_method](tcllib/files/modules/interp/deleg\_method\.md) &#183; [deleg\_proc](tcllib/files/modules/interp/deleg\_proc\.md) &#183; [nameserv::protocol](tcllib/files/modules/nns/nns\_protocol\.md)|
|<a name='command'></a>command|[doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md)|
|<a name='command\_line\_processing'></a>command line processing|[cmdline](tcllib/files/modules/cmdline/cmdline\.md)|
|<a name='command\_prefix'></a>command prefix|[lambda](tcllib/files/modules/lambda/lambda\.md) &#183; [oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='comment'></a>comment|[jpeg](tcllib/files/modules/jpeg/jpeg\.md) &#183; [png](tcllib/files/modules/png/png\.md)|
|<a name='common'></a>common|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='common\_prefix'></a>common prefix|[textutil::string](tcllib/files/modules/textutil/textutil\_string\.md)|
|<a name='communication'></a>communication|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md)|
|<a name='comparison'></a>comparison|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='complete\_graph'></a>complete graph|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='complex\_numbers'></a>complex numbers|[math::complexnumbers](tcllib/files/modules/math/qcomplex\.md) &#183; [math::fourier](tcllib/files/modules/math/fourier\.md)|
|<a name='compression'></a>compression|[tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md) &#183; [zipfile::encode](tcllib/files/modules/zip/encode\.md)|
|<a name='computations'></a>computations|[math::bigfloat](tcllib/files/modules/math/bigfloat\.md)|
|<a name='concatenation\_channel'></a>concatenation channel|[tcl::chan::cat](tcllib/files/modules/virtchannel\_base/cat\.md) &#183; [tcl::chan::facade](tcllib/files/modules/virtchannel\_base/facade\.md)|
|<a name='connected\_component'></a>connected component|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='connected\_fifos'></a>connected fifos|[tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md)|
|<a name='connection'></a>connection|[transfer::connect](tcllib/files/modules/transfer/connect\.md)|
|<a name='constants'></a>constants|[math::constants](tcllib/files/modules/math/constants\.md) &#183; [units](tcllib/files/modules/units/units\.md)|
|<a name='container'></a>CONTAINER|[pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md)|
|<a name='contents'></a>contents|[doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md)|
|<a name='context\_free\_grammar'></a>context\-free grammar|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md)|
|<a name='context\_free\_languages'></a>context\-free languages|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='control'></a>control|[control](tcllib/files/modules/control/control\.md) &#183; [math::changepoint](tcllib/files/modules/math/changepoint\.md) &#183; [term](tcllib/files/modules/term/term\.md) &#183; [term::ansi::code](tcllib/files/modules/term/ansi\_code\.md) &#183; [term::ansi::code::attr](tcllib/files/modules/term/ansi\_cattr\.md) &#183; [term::ansi::code::ctrl](tcllib/files/modules/term/ansi\_cctrl\.md) &#183; [term::ansi::code::macros](tcllib/files/modules/term/ansi\_cmacros\.md) &#183; [term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md) &#183; [term::ansi::send](tcllib/files/modules/term/ansi\_send\.md) &#183; [term::interact::menu](tcllib/files/modules/term/imenu\.md) &#183; [term::interact::pager](tcllib/files/modules/term/ipager\.md) &#183; [term::receive](tcllib/files/modules/term/receive\.md) &#183; [term::receive::bind](tcllib/files/modules/term/term\_bind\.md) &#183; [term::send](tcllib/files/modules/term/term\_send\.md)|
|<a name='control\_structure'></a>control structure|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='conversion'></a>conversion|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [math::roman](tcllib/files/modules/math/roman\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md) &#183; [units](tcllib/files/modules/units/units\.md)|
|<a name='cooked'></a>cooked|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='cookie'></a>cookie|[ncgi](tcllib/files/modules/ncgi/ncgi\.md)|
|<a name='copy'></a>copy|[fileutil::multi](tcllib/files/modules/fileutil/multi\.md) &#183; [fileutil::multi::op](tcllib/files/modules/fileutil/multiop\.md) &#183; [transfer::copy](tcllib/files/modules/transfer/copyops\.md) &#183; [transfer::copy::queue](tcllib/files/modules/transfer/tqueue\.md) &#183; [transfer::data::destination](tcllib/files/modules/transfer/ddest\.md) &#183; [transfer::data::source](tcllib/files/modules/transfer/dsource\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='coroutine'></a>coroutine|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md) &#183; [generator](tcllib/files/modules/generator/generator\.md)|
|<a name='cost'></a>Cost|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='counter'></a>counter|[tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md)|
|<a name='counting'></a>counting|[counter](tcllib/files/modules/counter/counter\.md)|
|<a name='cparam'></a>CPARAM|[pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md)|
|<a name='crc'></a>crc|[cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md)|
|<a name='crc16'></a>crc16|[crc16](tcllib/files/modules/crc/crc16\.md)|
|<a name='crc32'></a>crc32|[cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md)|
|<a name='credit\_card'></a>credit card|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md)|
|<a name='cron'></a>cron|[cron](tcllib/files/modules/cron/cron\.md)|
|<a name='cryptography'></a>cryptography|[blowfish](tcllib/files/modules/blowfish/blowfish\.md)|
|<a name='css'></a>CSS|[doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md)|
|<a name='csv'></a>csv|[bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::csv](tcllib/files/modules/bench/bench\_wcsv\.md) &#183; [csv](tcllib/files/modules/csv/csv\.md)|
|<a name='currying'></a>currying|[lambda](tcllib/files/modules/lambda/lambda\.md) &#183; [oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='cut\_edge'></a>cut edge|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='cut\_vertex'></a>cut vertex|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='cvs'></a>CVS|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='cvs'></a>cvs|[doctools::cvs](tcllib/files/modules/doctools/cvs\.md)|
|<a name='cvs\_log'></a>cvs log|[doctools::cvs](tcllib/files/modules/doctools/cvs\.md)|
|<a name='cyclic\_redundancy\_check'></a>cyclic redundancy check|[cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md)|


#### <a name='cD'></a>Keywords: D

|||
|---|---|
|<a name='data\_analysis'></a>data analysis|[math::statistics](tcllib/files/modules/math/statistics\.md)|
|<a name='data\_destination'></a>data destination|[transfer::data::destination](tcllib/files/modules/transfer/ddest\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md)|
|<a name='data\_entry\_form'></a>data entry form|[tepam::argument\_dialogbox](tcllib/files/modules/tepam/tepam\_argument\_dialogbox\.md)|
|<a name='data\_exchange'></a>data exchange|[huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [json](tcllib/files/modules/json/json\.md) &#183; [json::write](tcllib/files/modules/json/json\_write\.md) &#183; [yaml](tcllib/files/modules/yaml/yaml\.md)|
|<a name='data\_integrity'></a>data integrity|[aes](tcllib/files/modules/aes/aes\.md) &#183; [cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [des](tcllib/files/modules/des/des\.md) &#183; [pki](tcllib/files/modules/pki/pki\.md) &#183; [rc4](tcllib/files/modules/rc4/rc4\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|
|<a name='data\_source'></a>data source|[transfer::data::source](tcllib/files/modules/transfer/dsource\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='data\_structures'></a>data structures|[struct::record](tcllib/files/modules/struct/record\.md)|
|<a name='database'></a>database|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='dataflow'></a>dataflow|[page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md)|
|<a name='\_ddt'></a>\.ddt|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md)|
|<a name='de'></a>DE|[doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md)|
|<a name='debug'></a>debug|[debug](tcllib/files/modules/debug/debug\.md) &#183; [debug::caller](tcllib/files/modules/debug/debug\_caller\.md) &#183; [debug::heartbeat](tcllib/files/modules/debug/debug\_heartbeat\.md) &#183; [debug::timestamp](tcllib/files/modules/debug/debug\_timestamp\.md)|
|<a name='decimal'></a>decimal|[math::decimal](tcllib/files/modules/math/decimal\.md)|
|<a name='declare'></a>declare|[term::ansi::code](tcllib/files/modules/term/ansi\_code\.md)|
|<a name='decompression'></a>decompression|[tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md) &#183; [zipfile::decode](tcllib/files/modules/zip/decode\.md) &#183; [zipfile::mkzip](tcllib/files/modules/zip/mkzip\.md)|
|<a name='decryption'></a>decryption|[tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md)|
|<a name='deferal'></a>deferal|[uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='define'></a>define|[term::ansi::code](tcllib/files/modules/term/ansi\_code\.md)|
|<a name='degree'></a>degree|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='degree\_constrained\_spanning\_tree'></a>degree constrained spanning tree|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='degrees'></a>degrees|[math::constants](tcllib/files/modules/math/constants\.md)|
|<a name='delegation'></a>delegation|[deleg\_method](tcllib/files/modules/interp/deleg\_method\.md) &#183; [deleg\_proc](tcllib/files/modules/interp/deleg\_proc\.md)|
|<a name='depth\_first'></a>depth\-first|[struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='der'></a>der|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='des'></a>DES|[des](tcllib/files/modules/des/des\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|
|<a name='deserialization'></a>deserialization|[doctools::idx::import::docidx](tcllib/files/modules/doctools2idx/import\_docidx\.md) &#183; [doctools::idx::import::json](tcllib/files/modules/doctools2idx/idx\_import\_json\.md) &#183; [doctools::idx::structure](tcllib/files/modules/doctools2idx/idx\_structure\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md) &#183; [doctools::toc::structure](tcllib/files/modules/doctools2toc/toc\_structure\.md)|
|<a name='\_dev\_null'></a>/dev/null|[tcl::chan::null](tcllib/files/modules/virtchannel\_base/tcllib\_null\.md) &#183; [tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md)|
|<a name='\_dev\_random'></a>/dev/random|[tcl::chan::random](tcllib/files/modules/virtchannel\_base/tcllib\_random\.md) &#183; [tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md)|
|<a name='\_dev\_zero'></a>/dev/zero|[tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md) &#183; [tcl::chan::zero](tcllib/files/modules/virtchannel\_base/tcllib\_zero\.md)|
|<a name='diameter'></a>diameter|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='dict'></a>dict|[dicttool](tcllib/files/modules/dicttool/dicttool\.md)|
|<a name='diff'></a>diff|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='diff\_n\_format'></a>diff \-n format|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='diff\_run'></a>diff \-ruN|[textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='diff\_unified\_format'></a>diff, unified format|[textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='difference'></a>difference|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='differential'></a>differential|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='differential\_equations'></a>differential equations|[math::calculus](tcllib/files/modules/math/calculus\.md)|
|<a name='digital'></a>digital|[math::filters](tcllib/files/modules/math/filtergen\.md)|
|<a name='dijkstra'></a>dijkstra|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='directory\_access'></a>directory access|[ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md)|
|<a name='directory\_traversal'></a>directory traversal|[fileutil\_traverse](tcllib/files/modules/fileutil/traverse\.md)|
|<a name='discover'></a>Discover|[valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md)|
|<a name='discrete\_items'></a>discrete items|[struct::pool](tcllib/files/modules/struct/pool\.md)|
|<a name='disjoint\_set'></a>disjoint set|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='dispatcher'></a>dispatcher|[term::receive::bind](tcllib/files/modules/term/term\_bind\.md)|
|<a name='distance'></a>distance|[math::geometry](tcllib/files/modules/math/math\_geometry\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md) &#183; [units](tcllib/files/modules/units/units\.md)|
|<a name='dns'></a>DNS|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='do'></a>do|[control](tcllib/files/modules/control/control\.md)|
|<a name='docidx'></a>docidx|[doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::docidx](tcllib/files/modules/doctools2idx/export\_docidx\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::idx::import::docidx](tcllib/files/modules/doctools2idx/import\_docidx\.md) &#183; [doctools::idx::parse](tcllib/files/modules/doctools2idx/idx\_parse\.md) &#183; [doctools::idx::structure](tcllib/files/modules/doctools2idx/idx\_structure\.md) &#183; [doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md)|
|<a name='docidx\_commands'></a>docidx commands|[docidx\_lang\_cmdref](tcllib/files/modules/doctools/docidx\_lang\_cmdref\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md)|
|<a name='docidx\_language'></a>docidx language|[docidx\_lang\_cmdref](tcllib/files/modules/doctools/docidx\_lang\_cmdref\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md)|
|<a name='docidx\_markup'></a>docidx markup|[docidx\_lang\_cmdref](tcllib/files/modules/doctools/docidx\_lang\_cmdref\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md)|
|<a name='docidx\_syntax'></a>docidx syntax|[docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md)|
|<a name='docstrip'></a>docstrip|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|
|<a name='doctoc'></a>doctoc|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::parse](tcllib/files/modules/doctools2toc/toc\_parse\.md) &#183; [doctools::toc::structure](tcllib/files/modules/doctools2toc/toc\_structure\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md)|
|<a name='doctoc\_commands'></a>doctoc commands|[doctoc\_lang\_cmdref](tcllib/files/modules/doctools/doctoc\_lang\_cmdref\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md)|
|<a name='doctoc\_language'></a>doctoc language|[doctoc\_lang\_cmdref](tcllib/files/modules/doctools/doctoc\_lang\_cmdref\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md)|
|<a name='doctoc\_markup'></a>doctoc markup|[doctoc\_lang\_cmdref](tcllib/files/modules/doctools/doctoc\_lang\_cmdref\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md)|
|<a name='doctoc\_syntax'></a>doctoc syntax|[doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md)|
|<a name='doctools'></a>doctools|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [doctools::changelog](tcllib/files/modules/doctools/changelog\.md) &#183; [doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md) &#183; [doctools::idx::export::docidx](tcllib/files/modules/doctools2idx/export\_docidx\.md) &#183; [doctools::idx::export::html](tcllib/files/modules/doctools2idx/idx\_export\_html\.md) &#183; [doctools::idx::export::json](tcllib/files/modules/doctools2idx/idx\_export\_json\.md) &#183; [doctools::idx::export::nroff](tcllib/files/modules/doctools2idx/idx\_export\_nroff\.md) &#183; [doctools::idx::export::text](tcllib/files/modules/doctools2idx/idx\_export\_text\.md) &#183; [doctools::idx::export::wiki](tcllib/files/modules/doctools2idx/idx\_export\_wiki\.md) &#183; [doctools::idx::import::docidx](tcllib/files/modules/doctools2idx/import\_docidx\.md) &#183; [doctools::idx::import::json](tcllib/files/modules/doctools2idx/idx\_import\_json\.md) &#183; [doctools::idx::parse](tcllib/files/modules/doctools2idx/idx\_parse\.md) &#183; [doctools::idx::structure](tcllib/files/modules/doctools2idx/idx\_structure\.md) &#183; [doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md) &#183; [doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md) &#183; [doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md) &#183; [doctools::toc::parse](tcllib/files/modules/doctools2toc/toc\_parse\.md) &#183; [doctools::toc::structure](tcllib/files/modules/doctools2toc/toc\_structure\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md)|
|<a name='doctools\_commands'></a>doctools commands|[doctools\_lang\_cmdref](tcllib/files/modules/doctools/doctools\_lang\_cmdref\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md)|
|<a name='doctools\_language'></a>doctools language|[doctools\_lang\_cmdref](tcllib/files/modules/doctools/doctools\_lang\_cmdref\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md)|
|<a name='doctools\_markup'></a>doctools markup|[doctools\_lang\_cmdref](tcllib/files/modules/doctools/doctools\_lang\_cmdref\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md)|
|<a name='doctools\_syntax'></a>doctools syntax|[doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md)|
|<a name='document'></a>document|[doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md)|
|<a name='documentation'></a>documentation|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md) &#183; [tepam::doc\_gen](tcllib/files/modules/tepam/tepam\_doc\_gen\.md)|
|<a name='dom'></a>DOM|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='dom'></a>dom|[xsxp](tcllib/files/modules/amazon\-s3/xsxp\.md)|
|<a name='domain\_name\_service'></a>domain name service|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='\_dtx'></a>\.dtx|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|


#### <a name='cE'></a>Keywords: E

|||
|---|---|
|<a name='e'></a>e|[math::constants](tcllib/files/modules/math/constants\.md)|
|<a name='ean'></a>EAN|[valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='ean13'></a>EAN13|[valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='earley'></a>earley|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md)|
|<a name='ebnf'></a>EBNF|[pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='eccentricity'></a>eccentricity|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='edge'></a>edge|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='emacs'></a>emacs|[doctools::changelog](tcllib/files/modules/doctools/changelog\.md) &#183; [doctools::cvs](tcllib/files/modules/doctools/cvs\.md)|
|<a name='email'></a>email|[imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [mime](tcllib/files/modules/mime/mime\.md) &#183; [pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='emptiness'></a>emptiness|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='empty\_interpreter'></a>empty interpreter|[interp](tcllib/files/modules/interp/tcllib\_interp\.md)|
|<a name='en'></a>EN|[doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md)|
|<a name='encoding'></a>encoding|[ascii85](tcllib/files/modules/base64/ascii85\.md) &#183; [base64](tcllib/files/modules/base64/base64\.md) &#183; [uuencode](tcllib/files/modules/base64/uuencode\.md) &#183; [yencode](tcllib/files/modules/base64/yencode\.md)|
|<a name='encryption'></a>encryption|[aes](tcllib/files/modules/aes/aes\.md) &#183; [blowfish](tcllib/files/modules/blowfish/blowfish\.md) &#183; [des](tcllib/files/modules/des/des\.md) &#183; [pki](tcllib/files/modules/pki/pki\.md) &#183; [rc4](tcllib/files/modules/rc4/rc4\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|
|<a name='entry\_mask'></a>entry mask|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md)|
|<a name='equal'></a>equal|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='equality'></a>equality|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='equivalence\_class'></a>equivalence class|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='error'></a>error|[throw](tcllib/files/modules/try/tcllib\_throw\.md) &#183; [try](tcllib/files/modules/try/tcllib\_try\.md)|
|<a name='error\_function'></a>error function|[math::special](tcllib/files/modules/math/special\.md)|
|<a name='european\_article\_number'></a>European Article Number|[valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='event'></a>event|[hook](tcllib/files/modules/hook/hook\.md) &#183; [uevent](tcllib/files/modules/uev/uevent\.md) &#183; [uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='event\_management'></a>event management|[tcl::chan::events](tcllib/files/modules/virtchannel\_core/events\.md)|
|<a name='events'></a>events|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='examples'></a>examples|[bench\_lang\_intro](tcllib/files/modules/bench/bench\_lang\_intro\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md)|
|<a name='exception'></a>exception|[try](tcllib/files/modules/try/tcllib\_try\.md)|
|<a name='exchange\_format'></a>exchange format|[huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [json](tcllib/files/modules/json/json\.md) &#183; [json::write](tcllib/files/modules/json/json\_write\.md)|
|<a name='exclusion'></a>exclusion|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='execution'></a>execution|[grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md)|
|<a name='exif'></a>exif|[jpeg](tcllib/files/modules/jpeg/jpeg\.md)|
|<a name='exit'></a>exit|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='export'></a>export|[doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::docidx](tcllib/files/modules/doctools2idx/export\_docidx\.md) &#183; [doctools::idx::export::html](tcllib/files/modules/doctools2idx/idx\_export\_html\.md) &#183; [doctools::idx::export::json](tcllib/files/modules/doctools2idx/idx\_export\_json\.md) &#183; [doctools::idx::export::nroff](tcllib/files/modules/doctools2idx/idx\_export\_nroff\.md) &#183; [doctools::idx::export::text](tcllib/files/modules/doctools2idx/idx\_export\_text\.md) &#183; [doctools::idx::export::wiki](tcllib/files/modules/doctools2idx/idx\_export\_wiki\.md) &#183; [doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md)|
|<a name='expression'></a>expression|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='extended\_namespace'></a>extended namespace|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|


#### <a name='cF'></a>Keywords: F

|||
|---|---|
|<a name='faq'></a>faq|[docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md)|
|<a name='fetching\_information'></a>fetching information|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='fft'></a>FFT|[math::fourier](tcllib/files/modules/math/fourier\.md)|
|<a name='fifo'></a>fifo|[tcl::chan::fifo](tcllib/files/modules/virtchannel\_base/tcllib\_fifo\.md) &#183; [tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md) &#183; [tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md)|
|<a name='file'></a>file|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md)|
|<a name='file\_recognition'></a>file recognition|[fileutil::magic::cfront](tcllib/files/modules/fumagic/cfront\.md) &#183; [fileutil::magic::cgen](tcllib/files/modules/fumagic/cgen\.md) &#183; [fileutil::magic::filetype](tcllib/files/modules/fumagic/filetypes\.md) &#183; [fileutil::magic::rt](tcllib/files/modules/fumagic/rtcore\.md)|
|<a name='file\_type'></a>file type|[fileutil::magic::cfront](tcllib/files/modules/fumagic/cfront\.md) &#183; [fileutil::magic::cgen](tcllib/files/modules/fumagic/cgen\.md) &#183; [fileutil::magic::filetype](tcllib/files/modules/fumagic/filetypes\.md) &#183; [fileutil::magic::rt](tcllib/files/modules/fumagic/rtcore\.md)|
|<a name='file\_utilities'></a>file utilities|[fileutil](tcllib/files/modules/fileutil/fileutil\.md) &#183; [fileutil::magic::cfront](tcllib/files/modules/fumagic/cfront\.md) &#183; [fileutil::magic::cgen](tcllib/files/modules/fumagic/cgen\.md) &#183; [fileutil::magic::filetype](tcllib/files/modules/fumagic/filetypes\.md) &#183; [fileutil::magic::rt](tcllib/files/modules/fumagic/rtcore\.md) &#183; [fileutil::multi](tcllib/files/modules/fileutil/multi\.md) &#183; [fileutil::multi::op](tcllib/files/modules/fileutil/multiop\.md)|
|<a name='filesystem'></a>filesystem|[map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md)|
|<a name='filter'></a>filter|[generator](tcllib/files/modules/generator/generator\.md) &#183; [struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='filtering'></a>filtering|[math::filters](tcllib/files/modules/math/filtergen\.md)|
|<a name='final'></a>final|[try](tcllib/files/modules/try/tcllib\_try\.md)|
|<a name='finance'></a>finance|[valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md)|
|<a name='find'></a>find|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='finite'></a>finite|[struct::pool](tcllib/files/modules/struct/pool\.md)|
|<a name='finite\_automaton'></a>finite automaton|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md)|
|<a name='fips\_180\_1'></a>FIPS 180\-1|[sha1](tcllib/files/modules/sha1/sha1\.md) &#183; [sha256](tcllib/files/modules/sha1/sha256\.md)|
|<a name='first\_permutation'></a>first permutation|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='fisher\_yates'></a>Fisher\-Yates|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='flatten'></a>flatten|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='floating\_point'></a>floating\-point|[math::bigfloat](tcllib/files/modules/math/bigfloat\.md) &#183; [math::fuzzy](tcllib/files/modules/math/fuzzy\.md)|
|<a name='flow'></a>flow|[control](tcllib/files/modules/control/control\.md)|
|<a name='flow\_network'></a>flow network|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='folding'></a>folding|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='foldl'></a>foldl|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='foldr'></a>foldr|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='foreach'></a>foreach|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='form'></a>form|[html](tcllib/files/modules/html/html\.md) &#183; [ncgi](tcllib/files/modules/ncgi/ncgi\.md)|
|<a name='format\_conversion'></a>format conversion|[pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md)|
|<a name='formatter'></a>formatter|[doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md)|
|<a name='formatting'></a>formatting|[bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::csv](tcllib/files/modules/bench/bench\_wcsv\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md) &#183; [textutil::string](tcllib/files/modules/textutil/textutil\_string\.md) &#183; [textutil::tabify](tcllib/files/modules/textutil/tabify\.md)|
|<a name='formatting\_engine'></a>formatting engine|[docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md)|
|<a name='fossil'></a>fossil|[textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='fourier\_transform'></a>Fourier transform|[math::fourier](tcllib/files/modules/math/fourier\.md)|
|<a name='fr'></a>FR|[doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='frame'></a>frame|[term::ansi::code::macros](tcllib/files/modules/term/ansi\_cmacros\.md)|
|<a name='framework'></a>framework|[tool](tcllib/files/modules/tool/tool\.md)|
|<a name='ftp'></a>ftp|[ftp](tcllib/files/modules/ftp/ftp\.md) &#183; [ftp::geturl](tcllib/files/modules/ftp/ftp\_geturl\.md) &#183; [ftpd](tcllib/files/modules/ftpd/ftpd\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md)|
|<a name='ftpd'></a>ftpd|[ftpd](tcllib/files/modules/ftpd/ftpd\.md)|
|<a name='ftpserver'></a>ftpserver|[ftpd](tcllib/files/modules/ftpd/ftpd\.md)|
|<a name='full\_outer\_join'></a>full outer join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|


#### <a name='cG'></a>Keywords: G

|||
|---|---|
|<a name='generate\_event'></a>generate event|[uevent](tcllib/files/modules/uev/uevent\.md)|
|<a name='generate\_permutations'></a>generate permutations|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='generation'></a>generation|[doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md)|
|<a name='generator'></a>generator|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='geocoding'></a>geocoding|[map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md)|
|<a name='geodesy'></a>geodesy|[map::slippy](tcllib/files/modules/map/map\_slippy\.md) &#183; [mapproj](tcllib/files/modules/mapproj/mapproj\.md)|
|<a name='geography'></a>geography|[map::slippy](tcllib/files/modules/map/map\_slippy\.md)|
|<a name='get\_character'></a>get character|[term::receive](tcllib/files/modules/term/receive\.md)|
|<a name='gets'></a>gets|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='git'></a>git|[textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='global'></a>global|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='golang'></a>golang|[defer](tcllib/files/modules/defer/defer\.md)|
|<a name='gopher'></a>gopher|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='gps'></a>gps|[gpx](tcllib/files/modules/gpx/gpx\.md) &#183; [nmea](tcllib/files/modules/nmea/nmea\.md)|
|<a name='gpx'></a>gpx|[gpx](tcllib/files/modules/gpx/gpx\.md)|
|<a name='grammar'></a>grammar|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md) &#183; [grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md) &#183; [grammar::me::cpu](tcllib/files/modules/grammar\_me/me\_cpu\.md) &#183; [grammar::me::cpu::core](tcllib/files/modules/grammar\_me/me\_cpucore\.md) &#183; [grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md) &#183; [grammar::me::tcl](tcllib/files/modules/grammar\_me/me\_tcl\.md) &#183; [grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::me\_vm](tcllib/files/modules/grammar\_me/me\_vm\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='graph'></a>graph|[grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md) &#183; [struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md) &#183; [struct::graph\_v1](tcllib/files/modules/struct/graph1\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::stack](tcllib/files/modules/struct/stack\.md)|
|<a name='graph\_walking'></a>graph walking|[page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md)|
|<a name='green\_threads'></a>green threads|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='grep'></a>grep|[fileutil](tcllib/files/modules/fileutil/fileutil\.md)|
|<a name='guid'></a>GUID|[uuid](tcllib/files/modules/uuid/uuid\.md)|


#### <a name='cH'></a>Keywords: H

|||
|---|---|
|<a name='hashing'></a>hashing|[md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [md5crypt](tcllib/files/modules/md5crypt/md5crypt\.md) &#183; [otp](tcllib/files/modules/otp/otp\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md) &#183; [sha1](tcllib/files/modules/sha1/sha1\.md) &#183; [sha256](tcllib/files/modules/sha1/sha256\.md)|
|<a name='heartbeat'></a>heartbeat|[debug::heartbeat](tcllib/files/modules/debug/debug\_heartbeat\.md)|
|<a name='heuristic'></a>heuristic|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='hex'></a>hex|[base32::hex](tcllib/files/modules/base32/base32hex\.md)|
|<a name='hexadecimal'></a>hexadecimal|[tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md)|
|<a name='histogram'></a>histogram|[counter](tcllib/files/modules/counter/counter\.md)|
|<a name='hook'></a>hook|[hook](tcllib/files/modules/hook/hook\.md) &#183; [uevent](tcllib/files/modules/uev/uevent\.md)|
|<a name='horspool'></a>horspool|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md)|
|<a name='html'></a>HTML|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::html](tcllib/files/modules/doctools2idx/idx\_export\_html\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md)|
|<a name='html'></a>html|[html](tcllib/files/modules/html/html\.md) &#183; [htmlparse](tcllib/files/modules/htmlparse/htmlparse\.md) &#183; [javascript](tcllib/files/modules/javascript/javascript\.md) &#183; [ncgi](tcllib/files/modules/ncgi/ncgi\.md)|
|<a name='http'></a>http|[autoproxy](tcllib/files/modules/http/autoproxy\.md) &#183; [httpd](tcllib/files/modules/httpd/httpd\.md) &#183; [map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md) &#183; [websocket](tcllib/files/modules/websocket/websocket\.md)|
|<a name='httpd'></a>httpd|[httpd](tcllib/files/modules/httpd/httpd\.md)|
|<a name='https'></a>https|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='httpserver'></a>httpserver|[httpd](tcllib/files/modules/httpd/httpd\.md)|
|<a name='huddle'></a>huddle|[huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [yaml](tcllib/files/modules/yaml/yaml\.md)|
|<a name='human\_readable'></a>human readable|[bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md)|
|<a name='hyphenation'></a>hyphenation|[textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|


#### <a name='cI'></a>Keywords: I

|||
|---|---|
|<a name='i18n'></a>i18n|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='iban'></a>IBAN|[valtype::iban](tcllib/files/modules/valtype/iban\.md)|
|<a name='ident'></a>ident|[ident](tcllib/files/modules/ident/ident\.md)|
|<a name='identification'></a>identification|[ident](tcllib/files/modules/ident/ident\.md)|
|<a name='identity'></a>identity|[tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md)|
|<a name='idle'></a>idle|[uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='image'></a>image|[jpeg](tcllib/files/modules/jpeg/jpeg\.md) &#183; [png](tcllib/files/modules/png/png\.md) &#183; [tiff](tcllib/files/modules/tiff/tiff\.md)|
|<a name='imap'></a>imap|[imap4](tcllib/files/modules/imap4/imap4\.md)|
|<a name='imei'></a>IMEI|[valtype::imei](tcllib/files/modules/valtype/imei\.md)|
|<a name='import'></a>import|[doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::idx::import::docidx](tcllib/files/modules/doctools2idx/import\_docidx\.md) &#183; [doctools::idx::import::json](tcllib/files/modules/doctools2idx/idx\_import\_json\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md)|
|<a name='in\_memory\_channel'></a>in\-memory channel|[tcl::chan::fifo](tcllib/files/modules/virtchannel\_base/tcllib\_fifo\.md) &#183; [tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md) &#183; [tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md) &#183; [tcl::chan::memchan](tcllib/files/modules/virtchannel\_base/tcllib\_memchan\.md) &#183; [tcl::chan::string](tcllib/files/modules/virtchannel\_base/tcllib\_string\.md) &#183; [tcl::chan::variable](tcllib/files/modules/virtchannel\_base/tcllib\_variable\.md)|
|<a name='in\_order'></a>in\-order|[struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='inclusion'></a>inclusion|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='incr\_tcl'></a>Incr Tcl|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|
|<a name='indenting'></a>indenting|[textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|
|<a name='independent\_set'></a>independent set|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='index'></a>index|[docidx\_intro](tcllib/files/modules/doctools/docidx\_intro\.md) &#183; [docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::docidx](tcllib/files/modules/doctools2idx/export\_docidx\.md) &#183; [doctools::idx::export::html](tcllib/files/modules/doctools2idx/idx\_export\_html\.md) &#183; [doctools::idx::export::json](tcllib/files/modules/doctools2idx/idx\_export\_json\.md) &#183; [doctools::idx::export::nroff](tcllib/files/modules/doctools2idx/idx\_export\_nroff\.md) &#183; [doctools::idx::export::text](tcllib/files/modules/doctools2idx/idx\_export\_text\.md) &#183; [doctools::idx::export::wiki](tcllib/files/modules/doctools2idx/idx\_export\_wiki\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::idx::import::docidx](tcllib/files/modules/doctools2idx/import\_docidx\.md) &#183; [doctools::idx::import::json](tcllib/files/modules/doctools2idx/idx\_import\_json\.md)|
|<a name='index\_formatter'></a>index formatter|[docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md)|
|<a name='info'></a>info|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='inner\_join'></a>inner join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='input\_mode'></a>input mode|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='integer'></a>integer|[math::roman](tcllib/files/modules/math/roman\.md)|
|<a name='integration'></a>integration|[math::calculus](tcllib/files/modules/math/calculus\.md)|
|<a name='inter\_thread\_communication'></a>inter\-thread communication|[tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md)|
|<a name='international\_article\_number'></a>International Article Number|[valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='international\_bank\_account\_number'></a>International Bank Account Number|[valtype::iban](tcllib/files/modules/valtype/iban\.md)|
|<a name='international\_mobile\_equipment\_identity'></a>International Mobile Equipment Identity|[valtype::imei](tcllib/files/modules/valtype/imei\.md)|
|<a name='international\_standard\_book\_number'></a>International Standard Book Number|[valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='internationalization'></a>internationalization|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='internet'></a>internet|[asn](tcllib/files/modules/asn/asn\.md) &#183; [ftp](tcllib/files/modules/ftp/ftp\.md) &#183; [ftp::geturl](tcllib/files/modules/ftp/ftp\_geturl\.md) &#183; [imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md) &#183; [mime](tcllib/files/modules/mime/mime\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [pop3d::dbox](tcllib/files/modules/pop3d/pop3d\_dbox\.md) &#183; [pop3d::udb](tcllib/files/modules/pop3d/pop3d\_udb\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md) &#183; [websocket](tcllib/files/modules/websocket/websocket\.md)|
|<a name='internet\_address'></a>internet address|[tcllib\_ip](tcllib/files/modules/dns/tcllib\_ip\.md)|
|<a name='interpolation'></a>interpolation|[math::interpolate](tcllib/files/modules/math/interpolate\.md)|
|<a name='interpreter'></a>interpreter|[deleg\_method](tcllib/files/modules/interp/deleg\_method\.md) &#183; [deleg\_proc](tcllib/files/modules/interp/deleg\_proc\.md) &#183; [interp](tcllib/files/modules/interp/tcllib\_interp\.md) &#183; [wip](tcllib/files/modules/wip/wip\.md)|
|<a name='intersection'></a>intersection|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='interval'></a>interval|[math::bigfloat](tcllib/files/modules/math/bigfloat\.md)|
|<a name='ip'></a>ip|[tcllib\_ip](tcllib/files/modules/dns/tcllib\_ip\.md)|
|<a name='ipc'></a>ipc|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md)|
|<a name='ipv4'></a>ipv4|[tcllib\_ip](tcllib/files/modules/dns/tcllib\_ip\.md)|
|<a name='ipv6'></a>ipv6|[tcllib\_ip](tcllib/files/modules/dns/tcllib\_ip\.md)|
|<a name='irc'></a>irc|[irc](tcllib/files/modules/irc/irc\.md) &#183; [picoirc](tcllib/files/modules/irc/picoirc\.md)|
|<a name='isa'></a>isA|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='isbn'></a>ISBN|[valtype::isbn](tcllib/files/modules/valtype/isbn\.md)|
|<a name='isthmus'></a>isthmus|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='iterator'></a>iterator|[generator](tcllib/files/modules/generator/generator\.md)|


#### <a name='cJ'></a>Keywords: J

|||
|---|---|
|<a name='javascript'></a>javascript|[javascript](tcllib/files/modules/javascript/javascript\.md) &#183; [json](tcllib/files/modules/json/json\.md) &#183; [json::write](tcllib/files/modules/json/json\_write\.md)|
|<a name='jfif'></a>jfif|[jpeg](tcllib/files/modules/jpeg/jpeg\.md)|
|<a name='join'></a>join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='jpeg'></a>jpeg|[jpeg](tcllib/files/modules/jpeg/jpeg\.md)|
|<a name='json'></a>JSON|[doctools::idx::export::json](tcllib/files/modules/doctools2idx/idx\_export\_json\.md) &#183; [doctools::idx::import::json](tcllib/files/modules/doctools2idx/idx\_import\_json\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md)|
|<a name='json'></a>json|[doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [json](tcllib/files/modules/json/json\.md) &#183; [json::write](tcllib/files/modules/json/json\_write\.md)|
|<a name='justification'></a>justification|[textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|


#### <a name='cK'></a>Keywords: K

|||
|---|---|
|<a name='keyword\_index'></a>keyword index|[docidx\_intro](tcllib/files/modules/doctools/docidx\_intro\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md)|
|<a name='keywords'></a>keywords|[docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md)|
|<a name='knuth'></a>knuth|[soundex](tcllib/files/modules/soundex/soundex\.md)|


#### <a name='cL'></a>Keywords: L

|||
|---|---|
|<a name='l10n'></a>l10n|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='lambda'></a>lambda|[lambda](tcllib/files/modules/lambda/lambda\.md)|
|<a name='latex'></a>LaTeX|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|
|<a name='latex'></a>latex|[doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md)|
|<a name='latitute'></a>latitute|[map::slippy](tcllib/files/modules/map/map\_slippy\.md)|
|<a name='ldap'></a>ldap|[ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md)|
|<a name='ldap\_client'></a>ldap client|[ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md)|
|<a name='ldif'></a>ldif|[ldapx](tcllib/files/modules/ldap/ldapx\.md)|
|<a name='least\_squares'></a>least squares|[math::linearalgebra](tcllib/files/modules/math/linalg\.md)|
|<a name='left\_outer\_join'></a>left outer join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='lemon'></a>lemon|[page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md)|
|<a name='level\_graph'></a>level graph|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='lexer'></a>lexer|[doctools::idx::parse](tcllib/files/modules/doctools2idx/idx\_parse\.md) &#183; [doctools::toc::parse](tcllib/files/modules/doctools2toc/toc\_parse\.md)|
|<a name='lexing'></a>lexing|[string::token](tcllib/files/modules/string/token\.md) &#183; [string::token::shell](tcllib/files/modules/string/token\_shell\.md)|
|<a name='limitsize'></a>limitsize|[tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md)|
|<a name='line'></a>line|[math::geometry](tcllib/files/modules/math/math\_geometry\.md)|
|<a name='linear\_algebra'></a>linear algebra|[math::linearalgebra](tcllib/files/modules/math/linalg\.md)|
|<a name='linear\_equations'></a>linear equations|[math::linearalgebra](tcllib/files/modules/math/linalg\.md)|
|<a name='linear\_program'></a>linear program|[math::optimize](tcllib/files/modules/math/optimize\.md)|
|<a name='lines'></a>lines|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='list'></a>list|[struct::list](tcllib/files/modules/struct/struct\_list\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [wip](tcllib/files/modules/wip/wip\.md)|
|<a name='listener'></a>listener|[term::receive](tcllib/files/modules/term/receive\.md) &#183; [term::receive::bind](tcllib/files/modules/term/term\_bind\.md)|
|<a name='literate\_programming'></a>literate programming|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|
|<a name='ll\_k\_'></a>LL\(k\)|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='local\_searching'></a>local searching|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='localization'></a>localization|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='location'></a>location|[map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md) &#183; [map::slippy](tcllib/files/modules/map/map\_slippy\.md) &#183; [map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md)|
|<a name='log'></a>log|[debug](tcllib/files/modules/debug/debug\.md) &#183; [debug::caller](tcllib/files/modules/debug/debug\_caller\.md) &#183; [debug::heartbeat](tcllib/files/modules/debug/debug\_heartbeat\.md) &#183; [debug::timestamp](tcllib/files/modules/debug/debug\_timestamp\.md) &#183; [doctools::cvs](tcllib/files/modules/doctools/cvs\.md) &#183; [log](tcllib/files/modules/log/log\.md) &#183; [logger](tcllib/files/modules/log/logger\.md)|
|<a name='log\_level'></a>log level|[log](tcllib/files/modules/log/log\.md) &#183; [logger](tcllib/files/modules/log/logger\.md)|
|<a name='logger'></a>logger|[logger](tcllib/files/modules/log/logger\.md) &#183; [logger::appender](tcllib/files/modules/log/loggerAppender\.md) &#183; [logger::utils](tcllib/files/modules/log/loggerUtils\.md)|
|<a name='longest\_common\_subsequence'></a>longest common subsequence|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='longitude'></a>longitude|[map::slippy](tcllib/files/modules/map/map\_slippy\.md)|
|<a name='loop'></a>loop|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='luhn'></a>luhn|[valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md)|
|<a name='luhn\_5'></a>luhn\-5|[valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md)|


#### <a name='cM'></a>Keywords: M

|||
|---|---|
|<a name='macros'></a>macros|[doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md)|
|<a name='mail'></a>mail|[imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [mime](tcllib/files/modules/mime/mime\.md) &#183; [pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='mailto'></a>mailto|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='man\_macros'></a>man\_macros|[doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md)|
|<a name='manpage'></a>manpage|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md)|
|<a name='map'></a>map|[generator](tcllib/files/modules/generator/generator\.md) &#183; [map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md) &#183; [map::slippy](tcllib/files/modules/map/map\_slippy\.md) &#183; [map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md) &#183; [mapproj](tcllib/files/modules/mapproj/mapproj\.md) &#183; [struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='markdown'></a>markdown|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md)|
|<a name='markup'></a>markup|[docidx\_intro](tcllib/files/modules/doctools/docidx\_intro\.md) &#183; [docidx\_lang\_cmdref](tcllib/files/modules/doctools/docidx\_lang\_cmdref\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md) &#183; [docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md) &#183; [doctoc\_intro](tcllib/files/modules/doctools/doctoc\_intro\.md) &#183; [doctoc\_lang\_cmdref](tcllib/files/modules/doctools/doctoc\_lang\_cmdref\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [doctools\_intro](tcllib/files/modules/doctools/doctools\_intro\.md) &#183; [doctools\_lang\_cmdref](tcllib/files/modules/doctools/doctools\_lang\_cmdref\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md) &#183; [doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|
|<a name='mastercard'></a>MasterCard|[valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md)|
|<a name='matching'></a>matching|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='math'></a>math|[math](tcllib/files/modules/math/math\.md) &#183; [math::bigfloat](tcllib/files/modules/math/bigfloat\.md) &#183; [math::bignum](tcllib/files/modules/math/bignum\.md) &#183; [math::calculus](tcllib/files/modules/math/calculus\.md) &#183; [math::complexnumbers](tcllib/files/modules/math/qcomplex\.md) &#183; [math::constants](tcllib/files/modules/math/constants\.md) &#183; [math::decimal](tcllib/files/modules/math/decimal\.md) &#183; [math::fuzzy](tcllib/files/modules/math/fuzzy\.md) &#183; [math::geometry](tcllib/files/modules/math/math\_geometry\.md) &#183; [math::interpolate](tcllib/files/modules/math/interpolate\.md) &#183; [math::linearalgebra](tcllib/files/modules/math/linalg\.md) &#183; [math::optimize](tcllib/files/modules/math/optimize\.md) &#183; [math::PCA](tcllib/files/modules/math/pca\.md) &#183; [math::polynomials](tcllib/files/modules/math/polynomials\.md) &#183; [math::rationalfunctions](tcllib/files/modules/math/rational\_funcs\.md) &#183; [math::special](tcllib/files/modules/math/special\.md) &#183; [math::trig](tcllib/files/modules/math/trig\.md) &#183; [simulation::annealing](tcllib/files/modules/simulation/annealing\.md) &#183; [simulation::montecarlo](tcllib/files/modules/simulation/montecarlo\.md) &#183; [simulation::random](tcllib/files/modules/simulation/simulation\_random\.md)|
|<a name='mathematics'></a>mathematics|[math::fourier](tcllib/files/modules/math/fourier\.md) &#183; [math::probopt](tcllib/files/modules/math/probopt\.md) &#183; [math::quasirandom](tcllib/files/modules/math/quasirandom\.md) &#183; [math::statistics](tcllib/files/modules/math/statistics\.md)|
|<a name='matrices'></a>matrices|[math::linearalgebra](tcllib/files/modules/math/linalg\.md)|
|<a name='matrix'></a>matrix|[csv](tcllib/files/modules/csv/csv\.md) &#183; [math::linearalgebra](tcllib/files/modules/math/linalg\.md) &#183; [report](tcllib/files/modules/report/report\.md) &#183; [struct::matrix](tcllib/files/modules/struct/matrix\.md) &#183; [struct::matrix\_v1](tcllib/files/modules/struct/matrix1\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::stack](tcllib/files/modules/struct/stack\.md)|
|<a name='max\_cut'></a>max cut|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='maximum'></a>maximum|[math::optimize](tcllib/files/modules/math/optimize\.md)|
|<a name='maximum\_flow'></a>maximum flow|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='md4'></a>md4|[md4](tcllib/files/modules/md4/md4\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md)|
|<a name='md5'></a>md5|[md5](tcllib/files/modules/md5/md5\.md) &#183; [md5crypt](tcllib/files/modules/md5crypt/md5crypt\.md)|
|<a name='md5crypt'></a>md5crypt|[md5crypt](tcllib/files/modules/md5crypt/md5crypt\.md)|
|<a name='medicare'></a>medicare|[valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md)|
|<a name='mega\_widget'></a>mega widget|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|
|<a name='membership'></a>membership|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='menu'></a>menu|[term::ansi::code::macros](tcllib/files/modules/term/ansi\_cmacros\.md) &#183; [term::interact::menu](tcllib/files/modules/term/imenu\.md)|
|<a name='merge'></a>merge|[tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md) &#183; [uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='merge\_find'></a>merge find|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='merging'></a>merging|[bench](tcllib/files/modules/bench/bench\.md)|
|<a name='message'></a>message|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md) &#183; [log](tcllib/files/modules/log/log\.md)|
|<a name='message\_catalog'></a>message catalog|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='message\_level'></a>message level|[log](tcllib/files/modules/log/log\.md)|
|<a name='message\_package'></a>message package|[doctools::msgcat](tcllib/files/modules/doctools2base/tcllib\_msgcat\.md) &#183; [doctools::msgcat::idx::c](tcllib/files/modules/doctools2idx/idx\_msgcat\_c\.md) &#183; [doctools::msgcat::idx::de](tcllib/files/modules/doctools2idx/idx\_msgcat\_de\.md) &#183; [doctools::msgcat::idx::en](tcllib/files/modules/doctools2idx/idx\_msgcat\_en\.md) &#183; [doctools::msgcat::idx::fr](tcllib/files/modules/doctools2idx/idx\_msgcat\_fr\.md) &#183; [doctools::msgcat::toc::c](tcllib/files/modules/doctools2toc/toc\_msgcat\_c\.md) &#183; [doctools::msgcat::toc::de](tcllib/files/modules/doctools2toc/toc\_msgcat\_de\.md) &#183; [doctools::msgcat::toc::en](tcllib/files/modules/doctools2toc/toc\_msgcat\_en\.md) &#183; [doctools::msgcat::toc::fr](tcllib/files/modules/doctools2toc/toc\_msgcat\_fr\.md)|
|<a name='message\_digest'></a>message\-digest|[md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [md5crypt](tcllib/files/modules/md5crypt/md5crypt\.md) &#183; [otp](tcllib/files/modules/otp/otp\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md) &#183; [sha1](tcllib/files/modules/sha1/sha1\.md) &#183; [sha256](tcllib/files/modules/sha1/sha256\.md)|
|<a name='metakit'></a>metakit|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='method'></a>method|[deleg\_method](tcllib/files/modules/interp/deleg\_method\.md) &#183; [interp](tcllib/files/modules/interp/tcllib\_interp\.md)|
|<a name='method\_reference'></a>method reference|[oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='mime'></a>mime|[fileutil::magic::cfront](tcllib/files/modules/fumagic/cfront\.md) &#183; [fileutil::magic::cgen](tcllib/files/modules/fumagic/cgen\.md) &#183; [fileutil::magic::rt](tcllib/files/modules/fumagic/rtcore\.md) &#183; [mime](tcllib/files/modules/mime/mime\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='minimal\_spanning\_tree'></a>minimal spanning tree|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='minimum'></a>minimum|[math::optimize](tcllib/files/modules/math/optimize\.md)|
|<a name='minimum\_cost\_flow'></a>minimum cost flow|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='minimum\_degree\_spanning\_tree'></a>minimum degree spanning tree|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='minimum\_diameter\_spanning\_tree'></a>minimum diameter spanning tree|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='mobile\_phone'></a>mobile phone|[valtype::imei](tcllib/files/modules/valtype/imei\.md)|
|<a name='module'></a>module|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md)|
|<a name='montecarlo\_simulation'></a>montecarlo simulation|[simulation::montecarlo](tcllib/files/modules/simulation/montecarlo\.md)|
|<a name='move'></a>move|[fileutil::multi](tcllib/files/modules/fileutil/multi\.md) &#183; [fileutil::multi::op](tcllib/files/modules/fileutil/multiop\.md)|
|<a name='multi\_file'></a>multi\-file|[fileutil::multi](tcllib/files/modules/fileutil/multi\.md) &#183; [fileutil::multi::op](tcllib/files/modules/fileutil/multiop\.md)|
|<a name='multiplexer'></a>multiplexer|[multiplexer](tcllib/files/modules/multiplexer/multiplexer\.md)|
|<a name='multiprecision'></a>multiprecision|[math::bigfloat](tcllib/files/modules/math/bigfloat\.md) &#183; [math::bignum](tcllib/files/modules/math/bignum\.md)|
|<a name='my\_method'></a>my method|[oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|


#### <a name='cN'></a>Keywords: N

|||
|---|---|
|<a name='name\_service'></a>name service|[nameserv](tcllib/files/modules/nns/nns\_client\.md) &#183; [nameserv::auto](tcllib/files/modules/nns/nns\_auto\.md) &#183; [nameserv::common](tcllib/files/modules/nns/nns\_common\.md) &#183; [nameserv::protocol](tcllib/files/modules/nns/nns\_protocol\.md) &#183; [nameserv::server](tcllib/files/modules/nns/nns\_server\.md) &#183; [nns](tcllib/files/apps/nns\.md) &#183; [nns\_intro](tcllib/files/modules/nns/nns\_intro\.md) &#183; [nnsd](tcllib/files/apps/nnsd\.md) &#183; [nnslog](tcllib/files/apps/nnslog\.md) &#183; [udpcluster](tcllib/files/modules/udpcluster/udpcluster\.md)|
|<a name='namespace\_unknown'></a>namespace unknown|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='namespace\_utilities'></a>namespace utilities|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='narrative'></a>narrative|[debug](tcllib/files/modules/debug/debug\.md) &#183; [debug::caller](tcllib/files/modules/debug/debug\_caller\.md) &#183; [debug::heartbeat](tcllib/files/modules/debug/debug\_heartbeat\.md) &#183; [debug::timestamp](tcllib/files/modules/debug/debug\_timestamp\.md)|
|<a name='national\_provider\_identifier'></a>National Provider Identifier|[valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md)|
|<a name='neighbour'></a>neighbour|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='net'></a>net|[ftp](tcllib/files/modules/ftp/ftp\.md) &#183; [ftp::geturl](tcllib/files/modules/ftp/ftp\_geturl\.md) &#183; [imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [mime](tcllib/files/modules/mime/mime\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md) &#183; [websocket](tcllib/files/modules/websocket/websocket\.md)|
|<a name='nettool'></a>nettool|[nettool](tcllib/files/modules/nettool/nettool\.md)|
|<a name='network'></a>network|[pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [pop3d::dbox](tcllib/files/modules/pop3d/pop3d\_dbox\.md) &#183; [pop3d::udb](tcllib/files/modules/pop3d/pop3d\_udb\.md)|
|<a name='news'></a>news|[nntp](tcllib/files/modules/nntp/nntp\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md)|
|<a name='next\_permutation'></a>next permutation|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='nmea'></a>nmea|[nmea](tcllib/files/modules/nmea/nmea\.md)|
|<a name='nntp'></a>nntp|[nntp](tcllib/files/modules/nntp/nntp\.md)|
|<a name='nntpclient'></a>nntpclient|[nntp](tcllib/files/modules/nntp/nntp\.md)|
|<a name='no\_op'></a>no\-op|[control](tcllib/files/modules/control/control\.md)|
|<a name='node'></a>node|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md) &#183; [struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='nominatim'></a>nominatim|[map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md)|
|<a name='normalization'></a>normalization|[bench](tcllib/files/modules/bench/bench\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md) &#183; [unicode](tcllib/files/modules/stringprep/unicode\.md)|
|<a name='npi'></a>NPI|[valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md)|
|<a name='nroff'></a>nroff|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::nroff](tcllib/files/modules/doctools2idx/idx\_export\_nroff\.md) &#183; [doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md)|
|<a name='ntlm'></a>NTLM|[SASL::NTLM](tcllib/files/modules/sasl/ntlm\.md)|
|<a name='ntp'></a>NTP|[ntp\_time](tcllib/files/modules/ntp/ntp\_time\.md)|
|<a name='null'></a>null|[tcl::chan::null](tcllib/files/modules/virtchannel\_base/tcllib\_null\.md) &#183; [tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md)|
|<a name='number\_theory'></a>number theory|[math::numtheory](tcllib/files/modules/math/numtheory\.md)|


#### <a name='cO'></a>Keywords: O

|||
|---|---|
|<a name='oauth'></a>oauth|[oauth](tcllib/files/modules/oauth/oauth\.md)|
|<a name='object'></a>object|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md) &#183; [stooop](tcllib/files/modules/stooop/stooop\.md) &#183; [switched](tcllib/files/modules/stooop/switched\.md)|
|<a name='object\_oriented'></a>object oriented|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md) &#183; [stooop](tcllib/files/modules/stooop/stooop\.md) &#183; [switched](tcllib/files/modules/stooop/switched\.md)|
|<a name='observer'></a>observer|[hook](tcllib/files/modules/hook/hook\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md)|
|<a name='odie'></a>odie|[cron](tcllib/files/modules/cron/cron\.md) &#183; [nettool](tcllib/files/modules/nettool/nettool\.md) &#183; [processman](tcllib/files/modules/processman/processman\.md)|
|<a name='on\_idle'></a>on\-idle|[uevent::onidle](tcllib/files/modules/uev/uevent\_onidle\.md)|
|<a name='one\_time\_pad'></a>one time pad|[tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md)|
|<a name='oo'></a>oo|[clay](tcllib/files/modules/clay/clay\.md)|
|<a name='optimisation'></a>optimisation|[math::probopt](tcllib/files/modules/math/probopt\.md)|
|<a name='optimization'></a>optimization|[math::optimize](tcllib/files/modules/math/optimize\.md) &#183; [simulation::annealing](tcllib/files/modules/simulation/annealing\.md)|
|<a name='ordered\_list'></a>ordered list|[struct::prioqueue](tcllib/files/modules/struct/prioqueue\.md)|
|<a name='otp'></a>otp|[tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md)|
|<a name='outer\_join'></a>outer join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|


#### <a name='cP'></a>Keywords: P

|||
|---|---|
|<a name='package'></a>package|[csv](tcllib/files/modules/csv/csv\.md)|
|<a name='package\_indexing'></a>package indexing|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md)|
|<a name='page'></a>page|[page\_intro](tcllib/files/modules/page/page\_intro\.md) &#183; [page\_pluginmgr](tcllib/files/modules/page/page\_pluginmgr\.md) &#183; [page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md) &#183; [page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [page\_util\_quote](tcllib/files/modules/page/page\_util\_quote\.md)|
|<a name='pager'></a>pager|[term::interact::pager](tcllib/files/modules/term/ipager\.md)|
|<a name='paragraph'></a>paragraph|[textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|
|<a name='param'></a>PARAM|[pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md)|
|<a name='parameter\_entry\_form'></a>parameter entry form|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::argument\_dialogbox](tcllib/files/modules/tepam/tepam\_argument\_dialogbox\.md)|
|<a name='parser'></a>parser|[doctools::idx::parse](tcllib/files/modules/doctools2idx/idx\_parse\.md) &#183; [doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md) &#183; [doctools::toc::parse](tcllib/files/modules/doctools2toc/toc\_parse\.md) &#183; [grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md) &#183; [xsxp](tcllib/files/modules/amazon\-s3/xsxp\.md)|
|<a name='parser\_generator'></a>parser generator|[page](tcllib/files/apps/page\.md) &#183; [page\_intro](tcllib/files/modules/page/page\_intro\.md) &#183; [page\_pluginmgr](tcllib/files/modules/page/page\_pluginmgr\.md) &#183; [page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md) &#183; [page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [page\_util\_quote](tcllib/files/modules/page/page\_util\_quote\.md)|
|<a name='parsing'></a>parsing|[bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bibtex](tcllib/files/modules/bibtex/bibtex\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md) &#183; [grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md) &#183; [grammar::me::cpu](tcllib/files/modules/grammar\_me/me\_cpu\.md) &#183; [grammar::me::cpu::core](tcllib/files/modules/grammar\_me/me\_cpucore\.md) &#183; [grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md) &#183; [grammar::me::tcl](tcllib/files/modules/grammar\_me/me\_tcl\.md) &#183; [grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::me\_vm](tcllib/files/modules/grammar\_me/me\_vm\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [htmlparse](tcllib/files/modules/htmlparse/htmlparse\.md) &#183; [huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [string::token::shell](tcllib/files/modules/string/token\_shell\.md) &#183; [yaml](tcllib/files/modules/yaml/yaml\.md)|
|<a name='parsing\_expression'></a>parsing expression|[grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='parsing\_expression\_grammar'></a>parsing expression grammar|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='partial\_application'></a>partial application|[lambda](tcllib/files/modules/lambda/lambda\.md)|
|<a name='partition'></a>partition|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='partitioned\_set'></a>partitioned set|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md)|
|<a name='passive'></a>passive|[transfer::connect](tcllib/files/modules/transfer/connect\.md)|
|<a name='password'></a>password|[otp](tcllib/files/modules/otp/otp\.md)|
|<a name='patch'></a>patch|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='patching'></a>patching|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='pca'></a>PCA|[math::PCA](tcllib/files/modules/math/pca\.md)|
|<a name='peg'></a>PEG|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md) &#183; [page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='performance'></a>performance|[bench](tcllib/files/modules/bench/bench\.md) &#183; [bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::csv](tcllib/files/modules/bench/bench\_wcsv\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md) &#183; [bench\_intro](tcllib/files/modules/bench/bench\_intro\.md) &#183; [bench\_lang\_intro](tcllib/files/modules/bench/bench\_lang\_intro\.md) &#183; [bench\_lang\_spec](tcllib/files/modules/bench/bench\_lang\_spec\.md) &#183; [profiler](tcllib/files/modules/profiler/profiler\.md)|
|<a name='permutation'></a>permutation|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='persistence'></a>persistence|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='phone'></a>phone|[valtype::imei](tcllib/files/modules/valtype/imei\.md)|
|<a name='pi'></a>pi|[math::constants](tcllib/files/modules/math/constants\.md)|
|<a name='plain\_text'></a>plain text|[doctools::idx::export::text](tcllib/files/modules/doctools2idx/idx\_export\_text\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md)|
|<a name='plane\_geometry'></a>plane geometry|[math::geometry](tcllib/files/modules/math/math\_geometry\.md)|
|<a name='plugin'></a>plugin|[docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::nroff::man\_macros](tcllib/files/modules/doctools2base/nroff\_manmacros\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md)|
|<a name='plugin\_management'></a>plugin management|[pluginmgr](tcllib/files/modules/pluginmgr/pluginmgr\.md)|
|<a name='plugin\_search'></a>plugin search|[pluginmgr](tcllib/files/modules/pluginmgr/pluginmgr\.md)|
|<a name='png'></a>png|[png](tcllib/files/modules/png/png\.md)|
|<a name='point'></a>point|[math::geometry](tcllib/files/modules/math/math\_geometry\.md)|
|<a name='polynomial\_functions'></a>polynomial functions|[math::polynomials](tcllib/files/modules/math/polynomials\.md)|
|<a name='pool'></a>pool|[struct::pool](tcllib/files/modules/struct/pool\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md)|
|<a name='pop'></a>pop|[pop3](tcllib/files/modules/pop3/pop3\.md)|
|<a name='pop3'></a>pop3|[pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [pop3d::dbox](tcllib/files/modules/pop3d/pop3d\_dbox\.md) &#183; [pop3d::udb](tcllib/files/modules/pop3d/pop3d\_udb\.md)|
|<a name='post\_order'></a>post\-order|[struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='practcl'></a>practcl|[practcl](tcllib/files/modules/practcl/practcl\.md)|
|<a name='pre\_order'></a>pre\-order|[struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='prefix'></a>prefix|[textutil::string](tcllib/files/modules/textutil/textutil\_string\.md) &#183; [textutil::trim](tcllib/files/modules/textutil/trim\.md)|
|<a name='prime'></a>prime|[math::numtheory](tcllib/files/modules/math/numtheory\.md)|
|<a name='prioqueue'></a>prioqueue|[struct::prioqueue](tcllib/files/modules/struct/prioqueue\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md)|
|<a name='priority\_queue'></a>priority queue|[struct::prioqueue](tcllib/files/modules/struct/prioqueue\.md)|
|<a name='probabilistic\_calculations'></a>probabilistic calculations|[math::probopt](tcllib/files/modules/math/probopt\.md)|
|<a name='proc'></a>proc|[lambda](tcllib/files/modules/lambda/lambda\.md)|
|<a name='procedure'></a>procedure|[deleg\_proc](tcllib/files/modules/interp/deleg\_proc\.md) &#183; [tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::procedure](tcllib/files/modules/tepam/tepam\_procedure\.md)|
|<a name='procedure\_documentation'></a>procedure documentation|[tepam::doc\_gen](tcllib/files/modules/tepam/tepam\_doc\_gen\.md)|
|<a name='processman'></a>processman|[processman](tcllib/files/modules/processman/processman\.md)|
|<a name='producer'></a>producer|[hook](tcllib/files/modules/hook/hook\.md)|
|<a name='profile'></a>profile|[profiler](tcllib/files/modules/profiler/profiler\.md)|
|<a name='projection'></a>projection|[mapproj](tcllib/files/modules/mapproj/mapproj\.md)|
|<a name='prospero'></a>prospero|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='protocol'></a>protocol|[asn](tcllib/files/modules/asn/asn\.md) &#183; [ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md) &#183; [nameserv::protocol](tcllib/files/modules/nns/nns\_protocol\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [pop3d::dbox](tcllib/files/modules/pop3d/pop3d\_dbox\.md) &#183; [pop3d::udb](tcllib/files/modules/pop3d/pop3d\_udb\.md)|
|<a name='proxy'></a>proxy|[autoproxy](tcllib/files/modules/http/autoproxy\.md)|
|<a name='public\_key\_cipher'></a>public key cipher|[pki](tcllib/files/modules/pki/pki\.md)|
|<a name='publisher'></a>publisher|[hook](tcllib/files/modules/hook/hook\.md)|
|<a name='push\_down\_automaton'></a>push down automaton|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|


#### <a name='cQ'></a>Keywords: Q

|||
|---|---|
|<a name='quasi\_random'></a>quasi\-random|[math::quasirandom](tcllib/files/modules/math/quasirandom\.md)|
|<a name='queue'></a>queue|[csv](tcllib/files/modules/csv/csv\.md) &#183; [htmlparse](tcllib/files/modules/htmlparse/htmlparse\.md) &#183; [struct::stack](tcllib/files/modules/struct/stack\.md) &#183; [transfer::copy::queue](tcllib/files/modules/transfer/tqueue\.md)|
|<a name='quoting'></a>quoting|[page\_util\_quote](tcllib/files/modules/page/page\_util\_quote\.md)|


#### <a name='cR'></a>Keywords: R

|||
|---|---|
|<a name='radians'></a>radians|[math::constants](tcllib/files/modules/math/constants\.md) &#183; [units](tcllib/files/modules/units/units\.md)|
|<a name='radiobutton'></a>radiobutton|[html](tcllib/files/modules/html/html\.md)|
|<a name='radius'></a>radius|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='random'></a>random|[tcl::chan::random](tcllib/files/modules/virtchannel\_base/tcllib\_random\.md) &#183; [tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md)|
|<a name='random\_numbers'></a>random numbers|[simulation::random](tcllib/files/modules/simulation/simulation\_random\.md)|
|<a name='rational\_functions'></a>rational functions|[math::rationalfunctions](tcllib/files/modules/math/rational\_funcs\.md)|
|<a name='raw'></a>raw|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='rc4'></a>rc4|[rc4](tcllib/files/modules/rc4/rc4\.md)|
|<a name='rcs'></a>RCS|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='rcs\_patch'></a>RCS patch|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='read'></a>read|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='reading'></a>reading|[bench::in](tcllib/files/modules/bench/bench\_read\.md)|
|<a name='receiver'></a>receiver|[term::receive](tcllib/files/modules/term/receive\.md) &#183; [term::receive::bind](tcllib/files/modules/term/term\_bind\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md)|
|<a name='reconnect'></a>reconnect|[nameserv::auto](tcllib/files/modules/nns/nns\_auto\.md)|
|<a name='record'></a>record|[struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::record](tcllib/files/modules/struct/record\.md)|
|<a name='recursive\_descent'></a>recursive descent|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='reduce'></a>reduce|[generator](tcllib/files/modules/generator/generator\.md) &#183; [struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='reference'></a>reference|[doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md)|
|<a name='reflected\_channel'></a>reflected channel|[tcl::chan::cat](tcllib/files/modules/virtchannel\_base/cat\.md) &#183; [tcl::chan::core](tcllib/files/modules/virtchannel\_core/core\.md) &#183; [tcl::chan::events](tcllib/files/modules/virtchannel\_core/events\.md) &#183; [tcl::chan::facade](tcllib/files/modules/virtchannel\_base/facade\.md) &#183; [tcl::chan::fifo](tcllib/files/modules/virtchannel\_base/tcllib\_fifo\.md) &#183; [tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md) &#183; [tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md) &#183; [tcl::chan::memchan](tcllib/files/modules/virtchannel\_base/tcllib\_memchan\.md) &#183; [tcl::chan::null](tcllib/files/modules/virtchannel\_base/tcllib\_null\.md) &#183; [tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md) &#183; [tcl::chan::random](tcllib/files/modules/virtchannel\_base/tcllib\_random\.md) &#183; [tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md) &#183; [tcl::chan::string](tcllib/files/modules/virtchannel\_base/tcllib\_string\.md) &#183; [tcl::chan::textwindow](tcllib/files/modules/virtchannel\_base/textwindow\.md) &#183; [tcl::chan::variable](tcllib/files/modules/virtchannel\_base/tcllib\_variable\.md) &#183; [tcl::chan::zero](tcllib/files/modules/virtchannel\_base/tcllib\_zero\.md) &#183; [tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md) &#183; [tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md) &#183; [tcl::transform::core](tcllib/files/modules/virtchannel\_core/transformcore\.md) &#183; [tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md) &#183; [tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md) &#183; [tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md) &#183; [tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md) &#183; [tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='regex'></a>regex|[string::token](tcllib/files/modules/string/token\.md)|
|<a name='regular\_expression'></a>regular expression|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md) &#183; [textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::split](tcllib/files/modules/textutil/textutil\_split\.md) &#183; [textutil::trim](tcllib/files/modules/textutil/trim\.md)|
|<a name='regular\_grammar'></a>regular grammar|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md)|
|<a name='regular\_languages'></a>regular languages|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md)|
|<a name='remote\_communication'></a>remote communication|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md)|
|<a name='remote\_execution'></a>remote execution|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md)|
|<a name='remove'></a>remove|[fileutil::multi](tcllib/files/modules/fileutil/multi\.md) &#183; [fileutil::multi::op](tcllib/files/modules/fileutil/multiop\.md)|
|<a name='repeating'></a>repeating|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='repetition'></a>repetition|[struct::list](tcllib/files/modules/struct/struct\_list\.md) &#183; [textutil::repeat](tcllib/files/modules/textutil/repeat\.md)|
|<a name='report'></a>report|[report](tcllib/files/modules/report/report\.md)|
|<a name='reshuffle'></a>reshuffle|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='residual\_graph'></a>residual graph|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='resolver'></a>resolver|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='resource\_management'></a>resource management|[try](tcllib/files/modules/try/tcllib\_try\.md)|
|<a name='restore'></a>restore|[nameserv::auto](tcllib/files/modules/nns/nns\_auto\.md)|
|<a name='return'></a>return|[throw](tcllib/files/modules/try/tcllib\_throw\.md)|
|<a name='reverse'></a>reverse|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='rfc\_821'></a>rfc 821|[mime](tcllib/files/modules/mime/mime\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='rfc\_822'></a>rfc 822|[mime](tcllib/files/modules/mime/mime\.md) &#183; [pop3d::dbox](tcllib/files/modules/pop3d/pop3d\_dbox\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='rfc\_868'></a>rfc 868|[ntp\_time](tcllib/files/modules/ntp/ntp\_time\.md)|
|<a name='rfc\_959'></a>rfc 959|[ftp](tcllib/files/modules/ftp/ftp\.md) &#183; [ftp::geturl](tcllib/files/modules/ftp/ftp\_geturl\.md) &#183; [ftpd](tcllib/files/modules/ftpd/ftpd\.md)|
|<a name='rfc\_977'></a>rfc 977|[nntp](tcllib/files/modules/nntp/nntp\.md)|
|<a name='rfc\_1034'></a>rfc 1034|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='rfc\_1035'></a>rfc 1035|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='rfc\_1036'></a>rfc 1036|[nntp](tcllib/files/modules/nntp/nntp\.md)|
|<a name='rfc\_1320'></a>rfc 1320|[md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md)|
|<a name='rfc\_1321'></a>rfc 1321|[md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md)|
|<a name='rfc\_1413'></a>rfc 1413|[ident](tcllib/files/modules/ident/ident\.md)|
|<a name='rfc\_1630'></a>rfc 1630|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='rfc\_1886'></a>rfc 1886|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='rfc\_1939'></a>rfc 1939|[pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md)|
|<a name='rfc\_2030'></a>rfc 2030|[ntp\_time](tcllib/files/modules/ntp/ntp\_time\.md)|
|<a name='rfc\_2045'></a>rfc 2045|[mime](tcllib/files/modules/mime/mime\.md)|
|<a name='rfc\_2046'></a>rfc 2046|[mime](tcllib/files/modules/mime/mime\.md)|
|<a name='rfc\_2049'></a>rfc 2049|[mime](tcllib/files/modules/mime/mime\.md)|
|<a name='rfc\_2104'></a>rfc 2104|[md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md) &#183; [sha1](tcllib/files/modules/sha1/sha1\.md) &#183; [sha256](tcllib/files/modules/sha1/sha256\.md)|
|<a name='rfc\_2141'></a>rfc 2141|[uri\_urn](tcllib/files/modules/uri/urn\-scheme\.md)|
|<a name='rfc\_2251'></a>rfc 2251|[ldap](tcllib/files/modules/ldap/ldap\.md) &#183; [ldapx](tcllib/files/modules/ldap/ldapx\.md)|
|<a name='rfc\_2255'></a>rfc 2255|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='rfc\_2289'></a>rfc 2289|[otp](tcllib/files/modules/otp/otp\.md)|
|<a name='rfc\_2396'></a>rfc 2396|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='rfc\_2554'></a>rfc 2554|[smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='rfc\_2718'></a>RFC 2718|[oauth](tcllib/files/modules/oauth/oauth\.md)|
|<a name='rfc\_2821'></a>rfc 2821|[smtp](tcllib/files/modules/mime/smtp\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='rfc\_2849'></a>rfc 2849|[ldapx](tcllib/files/modules/ldap/ldapx\.md)|
|<a name='rfc\_3207'></a>rfc 3207|[smtp](tcllib/files/modules/mime/smtp\.md)|
|<a name='rfc\_3513'></a>rfc 3513|[tcllib\_ip](tcllib/files/modules/dns/tcllib\_ip\.md)|
|<a name='rfc\_3986'></a>rfc 3986|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='rfc\_4511'></a>rfc 4511|[ldap](tcllib/files/modules/ldap/ldap\.md)|
|<a name='rfc\_5849'></a>RFC 5849|[oauth](tcllib/files/modules/oauth/oauth\.md)|
|<a name='rfc\_6455'></a>rfc 6455|[websocket](tcllib/files/modules/websocket/websocket\.md)|
|<a name='rfc\_7858'></a>rfc 7858|[dns](tcllib/files/modules/dns/tcllib\_dns\.md)|
|<a name='rfc3501'></a>rfc3501|[imap4](tcllib/files/modules/imap4/imap4\.md)|
|<a name='rfc3548'></a>rfc3548|[base32](tcllib/files/modules/base32/base32\.md) &#183; [base32::hex](tcllib/files/modules/base32/base32hex\.md)|
|<a name='right\_outer\_join'></a>right outer join|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='ripemd'></a>RIPEMD|[ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md)|
|<a name='roman\_numeral'></a>roman numeral|[math::roman](tcllib/files/modules/math/roman\.md)|
|<a name='roots'></a>roots|[math::calculus](tcllib/files/modules/math/calculus\.md)|
|<a name='rot'></a>rot|[tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md)|
|<a name='rot13'></a>rot13|[tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md)|
|<a name='rounding'></a>rounding|[math::fuzzy](tcllib/files/modules/math/fuzzy\.md)|
|<a name='rows'></a>rows|[term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md)|
|<a name='rpc'></a>rpc|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md)|
|<a name='rsa'></a>rsa|[pki](tcllib/files/modules/pki/pki\.md)|
|<a name='running'></a>running|[grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md)|


#### <a name='cS'></a>Keywords: S

|||
|---|---|
|<a name='s3'></a>s3|[S3](tcllib/files/modules/amazon\-s3/S3\.md)|
|<a name='sasl'></a>SASL|[SASL](tcllib/files/modules/sasl/sasl\.md) &#183; [SASL::NTLM](tcllib/files/modules/sasl/ntlm\.md) &#183; [SASL::SCRAM](tcllib/files/modules/sasl/scram\.md) &#183; [SASL::XGoogleToken](tcllib/files/modules/sasl/gtoken\.md)|
|<a name='scanl'></a>scanl|[generator](tcllib/files/modules/generator/generator\.md)|
|<a name='sccs'></a>SCCS|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='scram'></a>SCRAM|[SASL::SCRAM](tcllib/files/modules/sasl/scram\.md)|
|<a name='secure'></a>secure|[comm](tcllib/files/modules/comm/comm\.md) &#183; [pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [transfer::connect](tcllib/files/modules/transfer/connect\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='security'></a>security|[aes](tcllib/files/modules/aes/aes\.md) &#183; [blowfish](tcllib/files/modules/blowfish/blowfish\.md) &#183; [cksum](tcllib/files/modules/crc/cksum\.md) &#183; [crc16](tcllib/files/modules/crc/crc16\.md) &#183; [crc32](tcllib/files/modules/crc/crc32\.md) &#183; [des](tcllib/files/modules/des/des\.md) &#183; [md4](tcllib/files/modules/md4/md4\.md) &#183; [md5](tcllib/files/modules/md5/md5\.md) &#183; [md5crypt](tcllib/files/modules/md5crypt/md5crypt\.md) &#183; [otp](tcllib/files/modules/otp/otp\.md) &#183; [pki](tcllib/files/modules/pki/pki\.md) &#183; [rc4](tcllib/files/modules/rc4/rc4\.md) &#183; [ripemd128](tcllib/files/modules/ripemd/ripemd128\.md) &#183; [ripemd160](tcllib/files/modules/ripemd/ripemd160\.md) &#183; [sha1](tcllib/files/modules/sha1/sha1\.md) &#183; [sha256](tcllib/files/modules/sha1/sha256\.md) &#183; [sum](tcllib/files/modules/crc/sum\.md) &#183; [tclDES](tcllib/files/modules/des/tcldes\.md) &#183; [tclDESjr](tcllib/files/modules/des/tcldesjr\.md)|
|<a name='seed'></a>seed|[tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md)|
|<a name='selectionbox'></a>selectionbox|[javascript](tcllib/files/modules/javascript/javascript\.md)|
|<a name='semantic\_markup'></a>semantic markup|[docidx\_intro](tcllib/files/modules/doctools/docidx\_intro\.md) &#183; [docidx\_lang\_cmdref](tcllib/files/modules/doctools/docidx\_lang\_cmdref\.md) &#183; [docidx\_lang\_faq](tcllib/files/modules/doctools/docidx\_lang\_faq\.md) &#183; [docidx\_lang\_intro](tcllib/files/modules/doctools/docidx\_lang\_intro\.md) &#183; [docidx\_lang\_syntax](tcllib/files/modules/doctools/docidx\_lang\_syntax\.md) &#183; [docidx\_plugin\_apiref](tcllib/files/modules/doctools/docidx\_plugin\_apiref\.md) &#183; [doctoc\_intro](tcllib/files/modules/doctools/doctoc\_intro\.md) &#183; [doctoc\_lang\_cmdref](tcllib/files/modules/doctools/doctoc\_lang\_cmdref\.md) &#183; [doctoc\_lang\_faq](tcllib/files/modules/doctools/doctoc\_lang\_faq\.md) &#183; [doctoc\_lang\_intro](tcllib/files/modules/doctools/doctoc\_lang\_intro\.md) &#183; [doctoc\_lang\_syntax](tcllib/files/modules/doctools/doctoc\_lang\_syntax\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools2idx\_introduction](tcllib/files/modules/doctools2idx/idx\_introduction\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools\_intro](tcllib/files/modules/doctools/doctools\_intro\.md) &#183; [doctools\_lang\_cmdref](tcllib/files/modules/doctools/doctools\_lang\_cmdref\.md) &#183; [doctools\_lang\_faq](tcllib/files/modules/doctools/doctools\_lang\_faq\.md) &#183; [doctools\_lang\_intro](tcllib/files/modules/doctools/doctools\_lang\_intro\.md) &#183; [doctools\_lang\_syntax](tcllib/files/modules/doctools/doctools\_lang\_syntax\.md) &#183; [doctools\_plugin\_apiref](tcllib/files/modules/doctools/doctools\_plugin\_apiref\.md)|
|<a name='send'></a>send|[comm](tcllib/files/modules/comm/comm\.md)|
|<a name='serialization'></a>serialization|[bee](tcllib/files/modules/bee/bee\.md) &#183; [doctools::idx::export::docidx](tcllib/files/modules/doctools2idx/export\_docidx\.md) &#183; [doctools::idx::export::html](tcllib/files/modules/doctools2idx/idx\_export\_html\.md) &#183; [doctools::idx::export::json](tcllib/files/modules/doctools2idx/idx\_export\_json\.md) &#183; [doctools::idx::export::nroff](tcllib/files/modules/doctools2idx/idx\_export\_nroff\.md) &#183; [doctools::idx::export::text](tcllib/files/modules/doctools2idx/idx\_export\_text\.md) &#183; [doctools::idx::export::wiki](tcllib/files/modules/doctools2idx/idx\_export\_wiki\.md) &#183; [doctools::idx::structure](tcllib/files/modules/doctools2idx/idx\_structure\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md) &#183; [doctools::toc::structure](tcllib/files/modules/doctools2toc/toc\_structure\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::tree](tcllib/files/modules/struct/struct\_tree\.md)|
|<a name='server'></a>server|[map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md) &#183; [nameserv::common](tcllib/files/modules/nns/nns\_common\.md) &#183; [nameserv::server](tcllib/files/modules/nns/nns\_server\.md) &#183; [nns\_intro](tcllib/files/modules/nns/nns\_intro\.md) &#183; [nnsd](tcllib/files/apps/nnsd\.md) &#183; [udpcluster](tcllib/files/modules/udpcluster/udpcluster\.md)|
|<a name='service'></a>service|[logger](tcllib/files/modules/log/logger\.md)|
|<a name='services'></a>services|[ftpd](tcllib/files/modules/ftpd/ftpd\.md) &#183; [httpd](tcllib/files/modules/httpd/httpd\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='set'></a>set|[struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='sha1'></a>sha1|[sha1](tcllib/files/modules/sha1/sha1\.md)|
|<a name='sha256'></a>sha256|[sha256](tcllib/files/modules/sha1/sha256\.md)|
|<a name='shell'></a>shell|[string::token::shell](tcllib/files/modules/string/token\_shell\.md)|
|<a name='shortest\_path'></a>shortest path|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='shuffle'></a>shuffle|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='simulated\_annealing'></a>simulated annealing|[simulation::annealing](tcllib/files/modules/simulation/annealing\.md)|
|<a name='simulation'></a>simulation|[simulation::random](tcllib/files/modules/simulation/simulation\_random\.md)|
|<a name='singleton'></a>singleton|[oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md)|
|<a name='size\_limit'></a>size limit|[tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md)|
|<a name='skiplist'></a>skiplist|[struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::skiplist](tcllib/files/modules/struct/skiplist\.md)|
|<a name='slippy'></a>slippy|[map::slippy](tcllib/files/modules/map/map\_slippy\.md) &#183; [map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md)|
|<a name='smtp'></a>smtp|[mime](tcllib/files/modules/mime/mime\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='smtpd'></a>smtpd|[smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='snit'></a>Snit|[snit](tcllib/files/modules/snit/snit\.md)|
|<a name='snit'></a>snit|[deleg\_method](tcllib/files/modules/interp/deleg\_method\.md) &#183; [interp](tcllib/files/modules/interp/tcllib\_interp\.md)|
|<a name='sntp'></a>SNTP|[ntp\_time](tcllib/files/modules/ntp/ntp\_time\.md)|
|<a name='socket'></a>socket|[comm](tcllib/files/modules/comm/comm\.md) &#183; [comm\_wire](tcllib/files/modules/comm/comm\_wire\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|
|<a name='soundex'></a>soundex|[soundex](tcllib/files/modules/soundex/soundex\.md)|
|<a name='source'></a>source|[docstrip](tcllib/files/modules/docstrip/docstrip\.md) &#183; [docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md) &#183; [tcldocstrip](tcllib/files/apps/tcldocstrip\.md)|
|<a name='spacing'></a>spacing|[tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md)|
|<a name='spatial\_interpolation'></a>spatial interpolation|[math::interpolate](tcllib/files/modules/math/interpolate\.md)|
|<a name='special\_functions'></a>special functions|[math::special](tcllib/files/modules/math/special\.md)|
|<a name='specification'></a>specification|[bench\_lang\_spec](tcllib/files/modules/bench/bench\_lang\_spec\.md)|
|<a name='speed'></a>speed|[profiler](tcllib/files/modules/profiler/profiler\.md)|
|<a name='split'></a>split|[textutil::split](tcllib/files/modules/textutil/textutil\_split\.md)|
|<a name='squared\_graph'></a>squared graph|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='ssl'></a>ssl|[comm](tcllib/files/modules/comm/comm\.md) &#183; [imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [transfer::connect](tcllib/files/modules/transfer/connect\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='stack'></a>stack|[struct::queue](tcllib/files/modules/struct/queue\.md)|
|<a name='standard\_io'></a>standard io|[tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md)|
|<a name='state'></a>state|[grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='state\_de\_serialization'></a>state \(de\)serialization|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='statistical\_distribution'></a>statistical distribution|[simulation::random](tcllib/files/modules/simulation/simulation\_random\.md)|
|<a name='statistics'></a>statistics|[counter](tcllib/files/modules/counter/counter\.md) &#183; [math](tcllib/files/modules/math/math\.md) &#183; [math::changepoint](tcllib/files/modules/math/changepoint\.md) &#183; [math::PCA](tcllib/files/modules/math/pca\.md) &#183; [math::statistics](tcllib/files/modules/math/statistics\.md)|
|<a name='stdin'></a>stdin|[tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md)|
|<a name='stdout'></a>stdout|[tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md)|
|<a name='stochastic\_modelling'></a>stochastic modelling|[simulation::montecarlo](tcllib/files/modules/simulation/montecarlo\.md)|
|<a name='stream\_cipher'></a>stream cipher|[rc4](tcllib/files/modules/rc4/rc4\.md)|
|<a name='stream\_copy'></a>stream copy|[tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md)|
|<a name='string'></a>string|[string::token](tcllib/files/modules/string/token\.md) &#183; [string::token::shell](tcllib/files/modules/string/token\_shell\.md) &#183; [textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md) &#183; [textutil::expander](tcllib/files/modules/textutil/expander\.md) &#183; [textutil::repeat](tcllib/files/modules/textutil/repeat\.md) &#183; [textutil::split](tcllib/files/modules/textutil/textutil\_split\.md) &#183; [textutil::string](tcllib/files/modules/textutil/textutil\_string\.md) &#183; [textutil::tabify](tcllib/files/modules/textutil/tabify\.md) &#183; [textutil::trim](tcllib/files/modules/textutil/trim\.md)|
|<a name='stringprep'></a>stringprep|[stringprep](tcllib/files/modules/stringprep/stringprep\.md) &#183; [stringprep::data](tcllib/files/modules/stringprep/stringprep\_data\.md) &#183; [unicode::data](tcllib/files/modules/stringprep/unicode\_data\.md)|
|<a name='strongly\_connected\_component'></a>strongly connected component|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='struct'></a>struct|[struct::pool](tcllib/files/modules/struct/pool\.md) &#183; [struct::record](tcllib/files/modules/struct/record\.md)|
|<a name='structure'></a>structure|[control](tcllib/files/modules/control/control\.md)|
|<a name='structured\_queries'></a>structured queries|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='style'></a>style|[doctools::html::cssdefaults](tcllib/files/modules/doctools2base/html\_cssdefaults\.md)|
|<a name='subcommand'></a>subcommand|[tepam](tcllib/files/modules/tepam/tepam\_introduction\.md) &#183; [tepam::procedure](tcllib/files/modules/tepam/tepam\_procedure\.md)|
|<a name='subgraph'></a>subgraph|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='subject'></a>subject|[hook](tcllib/files/modules/hook/hook\.md)|
|<a name='submitbutton'></a>submitbutton|[javascript](tcllib/files/modules/javascript/javascript\.md)|
|<a name='subscriber'></a>subscriber|[hook](tcllib/files/modules/hook/hook\.md)|
|<a name='subsequence'></a>subsequence|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='subst'></a>subst|[doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md)|
|<a name='sum'></a>sum|[sum](tcllib/files/modules/crc/sum\.md)|
|<a name='swapping'></a>swapping|[struct::list](tcllib/files/modules/struct/struct\_list\.md)|
|<a name='symmetric\_difference'></a>symmetric difference|[struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='synchronous'></a>synchronous|[cache::async](tcllib/files/modules/cache/async\.md)|
|<a name='syntax\_tree'></a>syntax tree|[grammar::me::util](tcllib/files/modules/grammar\_me/me\_util\.md)|


#### <a name='cT'></a>Keywords: T

|||
|---|---|
|<a name='table'></a>table|[doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [html](tcllib/files/modules/html/html\.md) &#183; [report](tcllib/files/modules/report/report\.md)|
|<a name='table\_of\_contents'></a>table of contents|[doctoc\_intro](tcllib/files/modules/doctools/doctoc\_intro\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools2toc\_introduction](tcllib/files/modules/doctools2toc/toc\_introduction\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md)|
|<a name='tabstops'></a>tabstops|[textutil::tabify](tcllib/files/modules/textutil/tabify\.md)|
|<a name='tallying'></a>tallying|[counter](tcllib/files/modules/counter/counter\.md)|
|<a name='tape\_archive'></a>tape archive|[tar](tcllib/files/modules/tar/tar\.md)|
|<a name='tar'></a>tar|[tar](tcllib/files/modules/tar/tar\.md)|
|<a name='tcl'></a>tcl|[math::bigfloat](tcllib/files/modules/math/bigfloat\.md) &#183; [math::bignum](tcllib/files/modules/math/bignum\.md) &#183; [math::decimal](tcllib/files/modules/math/decimal\.md) &#183; [math::PCA](tcllib/files/modules/math/pca\.md)|
|<a name='tcl\_module'></a>Tcl module|[docstrip\_util](tcllib/files/modules/docstrip/docstrip\_util\.md)|
|<a name='tcl\_syntax'></a>Tcl syntax|[doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md)|
|<a name='tcler\_s\_wiki'></a>tcler's wiki|[doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md)|
|<a name='tcllib'></a>tcllib|[csv](tcllib/files/modules/csv/csv\.md)|
|<a name='tcloo'></a>TclOO|[clay](tcllib/files/modules/clay/clay\.md) &#183; [httpd](tcllib/files/modules/httpd/httpd\.md) &#183; [oo::util](tcllib/files/modules/tool/meta\.md) &#183; [oo::util](tcllib/files/modules/ooutil/ooutil\.md) &#183; [oometa](tcllib/files/modules/oometa/oometa\.md) &#183; [tool](tcllib/files/modules/tool/tool\.md) &#183; [tool::dict\_ensemble](tcllib/files/modules/tool/tool\_dict\_ensemble\.md)|
|<a name='tclparam'></a>TCLPARAM|[pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md)|
|<a name='tdpl'></a>TDPL|[grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='temp\_file'></a>temp file|[fileutil](tcllib/files/modules/fileutil/fileutil\.md)|
|<a name='template\_processing'></a>template processing|[textutil::expander](tcllib/files/modules/textutil/expander\.md)|
|<a name='terminal'></a>terminal|[term](tcllib/files/modules/term/term\.md) &#183; [term::ansi::code](tcllib/files/modules/term/ansi\_code\.md) &#183; [term::ansi::code::attr](tcllib/files/modules/term/ansi\_cattr\.md) &#183; [term::ansi::code::ctrl](tcllib/files/modules/term/ansi\_cctrl\.md) &#183; [term::ansi::code::macros](tcllib/files/modules/term/ansi\_cmacros\.md) &#183; [term::ansi::ctrl::unix](tcllib/files/modules/term/ansi\_ctrlu\.md) &#183; [term::ansi::send](tcllib/files/modules/term/ansi\_send\.md) &#183; [term::interact::menu](tcllib/files/modules/term/imenu\.md) &#183; [term::interact::pager](tcllib/files/modules/term/ipager\.md) &#183; [term::receive](tcllib/files/modules/term/receive\.md) &#183; [term::receive::bind](tcllib/files/modules/term/term\_bind\.md) &#183; [term::send](tcllib/files/modules/term/term\_send\.md)|
|<a name='test'></a>test|[fileutil](tcllib/files/modules/fileutil/fileutil\.md)|
|<a name='testing'></a>Testing|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='testing'></a>testing|[bench](tcllib/files/modules/bench/bench\.md) &#183; [bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::csv](tcllib/files/modules/bench/bench\_wcsv\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md) &#183; [bench\_intro](tcllib/files/modules/bench/bench\_intro\.md) &#183; [bench\_lang\_intro](tcllib/files/modules/bench/bench\_lang\_intro\.md) &#183; [bench\_lang\_spec](tcllib/files/modules/bench/bench\_lang\_spec\.md)|
|<a name='tex'></a>TeX|[textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|
|<a name='text'></a>text|[bench::in](tcllib/files/modules/bench/bench\_read\.md) &#183; [bench::out::text](tcllib/files/modules/bench/bench\_wtext\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md)|
|<a name='text\_comparison'></a>text comparison|[soundex](tcllib/files/modules/soundex/soundex\.md)|
|<a name='text\_conversion'></a>text conversion|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='text\_differences'></a>text differences|[rcs](tcllib/files/modules/rcs/rcs\.md)|
|<a name='text\_display'></a>text display|[term::interact::menu](tcllib/files/modules/term/imenu\.md) &#183; [term::interact::pager](tcllib/files/modules/term/ipager\.md)|
|<a name='text\_expansion'></a>text expansion|[textutil::expander](tcllib/files/modules/textutil/expander\.md)|
|<a name='text\_likeness'></a>text likeness|[soundex](tcllib/files/modules/soundex/soundex\.md)|
|<a name='text\_processing'></a>text processing|[bibtex](tcllib/files/modules/bibtex/bibtex\.md) &#183; [huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [page](tcllib/files/apps/page\.md) &#183; [page\_intro](tcllib/files/modules/page/page\_intro\.md) &#183; [page\_pluginmgr](tcllib/files/modules/page/page\_pluginmgr\.md) &#183; [page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md) &#183; [page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [page\_util\_quote](tcllib/files/modules/page/page\_util\_quote\.md) &#183; [yaml](tcllib/files/modules/yaml/yaml\.md)|
|<a name='text\_widget'></a>text widget|[tcl::chan::textwindow](tcllib/files/modules/virtchannel\_base/textwindow\.md)|
|<a name='threads'></a>threads|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='throw'></a>throw|[throw](tcllib/files/modules/try/tcllib\_throw\.md)|
|<a name='thumbnail'></a>thumbnail|[jpeg](tcllib/files/modules/jpeg/jpeg\.md)|
|<a name='tie'></a>tie|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='tif'></a>tif|[tiff](tcllib/files/modules/tiff/tiff\.md)|
|<a name='tiff'></a>tiff|[tiff](tcllib/files/modules/tiff/tiff\.md)|
|<a name='tile'></a>tile|[map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md)|
|<a name='time'></a>time|[ntp\_time](tcllib/files/modules/ntp/ntp\_time\.md)|
|<a name='timestamp'></a>timestamp|[png](tcllib/files/modules/png/png\.md)|
|<a name='timestamps'></a>timestamps|[debug::timestamp](tcllib/files/modules/debug/debug\_timestamp\.md)|
|<a name='tip\_219'></a>tip 219|[tcl::chan::cat](tcllib/files/modules/virtchannel\_base/cat\.md) &#183; [tcl::chan::core](tcllib/files/modules/virtchannel\_core/core\.md) &#183; [tcl::chan::events](tcllib/files/modules/virtchannel\_core/events\.md) &#183; [tcl::chan::facade](tcllib/files/modules/virtchannel\_base/facade\.md) &#183; [tcl::chan::fifo](tcllib/files/modules/virtchannel\_base/tcllib\_fifo\.md) &#183; [tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md) &#183; [tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md) &#183; [tcl::chan::memchan](tcllib/files/modules/virtchannel\_base/tcllib\_memchan\.md) &#183; [tcl::chan::null](tcllib/files/modules/virtchannel\_base/tcllib\_null\.md) &#183; [tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md) &#183; [tcl::chan::random](tcllib/files/modules/virtchannel\_base/tcllib\_random\.md) &#183; [tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md) &#183; [tcl::chan::string](tcllib/files/modules/virtchannel\_base/tcllib\_string\.md) &#183; [tcl::chan::textwindow](tcllib/files/modules/virtchannel\_base/textwindow\.md) &#183; [tcl::chan::variable](tcllib/files/modules/virtchannel\_base/tcllib\_variable\.md) &#183; [tcl::chan::zero](tcllib/files/modules/virtchannel\_base/tcllib\_zero\.md) &#183; [tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md) &#183; [tcl::transform::core](tcllib/files/modules/virtchannel\_core/transformcore\.md)|
|<a name='tip\_230'></a>tip 230|[tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md) &#183; [tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md) &#183; [tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md) &#183; [tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md) &#183; [tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md) &#183; [tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='tip\_234'></a>tip 234|[tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='tip\_317'></a>tip 317|[tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md)|
|<a name='tk'></a>Tk|[tcl::chan::textwindow](tcllib/files/modules/virtchannel\_base/textwindow\.md)|
|<a name='tls'></a>tls|[comm](tcllib/files/modules/comm/comm\.md) &#183; [imap4](tcllib/files/modules/imap4/imap4\.md) &#183; [pop3](tcllib/files/modules/pop3/pop3\.md) &#183; [pop3d](tcllib/files/modules/pop3d/pop3d\.md) &#183; [smtp](tcllib/files/modules/mime/smtp\.md) &#183; [transfer::connect](tcllib/files/modules/transfer/connect\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='tmml'></a>TMML|[doctools](tcllib/files/modules/doctools/doctools\.md) &#183; [doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [dtplite](tcllib/files/modules/dtplite/pkg\_dtplite\.md) &#183; [dtplite](tcllib/files/apps/dtplite\.md) &#183; [mpexpand](tcllib/files/modules/doctools/mpexpand\.md)|
|<a name='toc'></a>toc|[doctoc\_intro](tcllib/files/modules/doctools/doctoc\_intro\.md) &#183; [doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export::doctoc](tcllib/files/modules/doctools2toc/export\_doctoc\.md) &#183; [doctools::toc::export::html](tcllib/files/modules/doctools2toc/toc\_export\_html\.md) &#183; [doctools::toc::export::json](tcllib/files/modules/doctools2toc/toc\_export\_json\.md) &#183; [doctools::toc::export::nroff](tcllib/files/modules/doctools2toc/toc\_export\_nroff\.md) &#183; [doctools::toc::export::text](tcllib/files/modules/doctools2toc/toc\_export\_text\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md) &#183; [doctools::toc::import::doctoc](tcllib/files/modules/doctools2toc/import\_doctoc\.md) &#183; [doctools::toc::import::json](tcllib/files/modules/doctools2toc/toc\_import\_json\.md)|
|<a name='toc\_formatter'></a>toc formatter|[doctoc\_plugin\_apiref](tcllib/files/modules/doctools/doctoc\_plugin\_apiref\.md)|
|<a name='tokenization'></a>tokenization|[string::token](tcllib/files/modules/string/token\.md) &#183; [string::token::shell](tcllib/files/modules/string/token\_shell\.md)|
|<a name='tool'></a>TOOL|[oometa](tcllib/files/modules/oometa/oometa\.md) &#183; [tool](tcllib/files/modules/tool/tool\.md) &#183; [tool::dict\_ensemble](tcllib/files/modules/tool/tool\_dict\_ensemble\.md)|
|<a name='top\_down\_parsing\_languages'></a>top\-down parsing languages|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='torrent'></a>torrent|[bee](tcllib/files/modules/bee/bee\.md)|
|<a name='touch'></a>touch|[fileutil](tcllib/files/modules/fileutil/fileutil\.md)|
|<a name='tpdl'></a>TPDL|[grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md)|
|<a name='trace'></a>trace|[debug](tcllib/files/modules/debug/debug\.md) &#183; [debug::caller](tcllib/files/modules/debug/debug\_caller\.md) &#183; [debug::heartbeat](tcllib/files/modules/debug/debug\_heartbeat\.md) &#183; [debug::timestamp](tcllib/files/modules/debug/debug\_timestamp\.md)|
|<a name='transducer'></a>transducer|[grammar::aycock](tcllib/files/modules/grammar\_aycock/aycock\.md) &#183; [grammar::fa](tcllib/files/modules/grammar\_fa/fa\.md) &#183; [grammar::fa::dacceptor](tcllib/files/modules/grammar\_fa/dacceptor\.md) &#183; [grammar::fa::dexec](tcllib/files/modules/grammar\_fa/dexec\.md) &#183; [grammar::fa::op](tcllib/files/modules/grammar\_fa/faop\.md) &#183; [grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::peg](tcllib/files/modules/grammar\_peg/peg\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt](tcllib/files/apps/pt\.md) &#183; [pt::ast](tcllib/files/modules/pt/pt\_astree\.md) &#183; [pt::cparam::configuration::critcl](tcllib/files/modules/pt/pt\_cparam\_config\_critcl\.md) &#183; [pt::cparam::configuration::tea](tcllib/files/modules/pt/pt\_cparam\_config\_tea\.md) &#183; [pt::json\_language](tcllib/files/modules/pt/pt\_json\_language\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md) &#183; [pt::pe](tcllib/files/modules/pt/pt\_pexpression\.md) &#183; [pt::pe::op](tcllib/files/modules/pt/pt\_pexpr\_op\.md) &#183; [pt::peg](tcllib/files/modules/pt/pt\_pegrammar\.md) &#183; [pt::peg::container](tcllib/files/modules/pt/pt\_peg\_container\.md) &#183; [pt::peg::container::peg](tcllib/files/modules/pt/pt\_peg\_container\_peg\.md) &#183; [pt::peg::export](tcllib/files/modules/pt/pt\_peg\_export\.md) &#183; [pt::peg::export::container](tcllib/files/modules/pt/pt\_peg\_export\_container\.md) &#183; [pt::peg::export::json](tcllib/files/modules/pt/pt\_peg\_export\_json\.md) &#183; [pt::peg::export::peg](tcllib/files/modules/pt/pt\_peg\_export\_peg\.md) &#183; [pt::peg::from::container](tcllib/files/modules/pt/pt\_peg\_from\_container\.md) &#183; [pt::peg::from::json](tcllib/files/modules/pt/pt\_peg\_from\_json\.md) &#183; [pt::peg::from::peg](tcllib/files/modules/pt/pt\_peg\_from\_peg\.md) &#183; [pt::peg::import](tcllib/files/modules/pt/pt\_peg\_import\.md) &#183; [pt::peg::import::container](tcllib/files/modules/pt/pt\_peg\_import\_container\.md) &#183; [pt::peg::import::json](tcllib/files/modules/pt/pt\_peg\_import\_json\.md) &#183; [pt::peg::import::peg](tcllib/files/modules/pt/pt\_peg\_import\_peg\.md) &#183; [pt::peg::interp](tcllib/files/modules/pt/pt\_peg\_interp\.md) &#183; [pt::peg::to::container](tcllib/files/modules/pt/pt\_peg\_to\_container\.md) &#183; [pt::peg::to::cparam](tcllib/files/modules/pt/pt\_peg\_to\_cparam\.md) &#183; [pt::peg::to::json](tcllib/files/modules/pt/pt\_peg\_to\_json\.md) &#183; [pt::peg::to::param](tcllib/files/modules/pt/pt\_peg\_to\_param\.md) &#183; [pt::peg::to::peg](tcllib/files/modules/pt/pt\_peg\_to\_peg\.md) &#183; [pt::peg::to::tclparam](tcllib/files/modules/pt/pt\_peg\_to\_tclparam\.md) &#183; [pt::peg\_language](tcllib/files/modules/pt/pt\_peg\_language\.md) &#183; [pt::pegrammar](tcllib/files/modules/pt/pt\_peg\_introduction\.md) &#183; [pt::pgen](tcllib/files/modules/pt/pt\_pgen\.md) &#183; [pt::rde](tcllib/files/modules/pt/pt\_rdengine\.md) &#183; [pt::tclparam::configuration::nx](tcllib/files/modules/pt/pt\_tclparam\_config\_nx\.md) &#183; [pt::tclparam::configuration::snit](tcllib/files/modules/pt/pt\_tclparam\_config\_snit\.md) &#183; [pt::tclparam::configuration::tcloo](tcllib/files/modules/pt/pt\_tclparam\_config\_tcloo\.md) &#183; [pt::util](tcllib/files/modules/pt/pt\_util\.md) &#183; [pt\_export\_api](tcllib/files/modules/pt/pt\_to\_api\.md) &#183; [pt\_import\_api](tcllib/files/modules/pt/pt\_from\_api\.md) &#183; [pt\_introduction](tcllib/files/modules/pt/pt\_introduction\.md) &#183; [pt\_parse\_peg](tcllib/files/modules/pt/pt\_parse\_peg\.md) &#183; [pt\_parser\_api](tcllib/files/modules/pt/pt\_parser\_api\.md) &#183; [pt\_peg\_op](tcllib/files/modules/pt/pt\_peg\_op\.md)|
|<a name='transfer'></a>transfer|[transfer::connect](tcllib/files/modules/transfer/connect\.md) &#183; [transfer::copy](tcllib/files/modules/transfer/copyops\.md) &#183; [transfer::copy::queue](tcllib/files/modules/transfer/tqueue\.md) &#183; [transfer::data::destination](tcllib/files/modules/transfer/ddest\.md) &#183; [transfer::data::source](tcllib/files/modules/transfer/dsource\.md) &#183; [transfer::receiver](tcllib/files/modules/transfer/receiver\.md) &#183; [transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='transformation'></a>transformation|[page\_util\_peg](tcllib/files/modules/page/page\_util\_peg\.md) &#183; [tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md) &#183; [tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md) &#183; [tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md) &#183; [tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md) &#183; [tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md) &#183; [tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='transmitter'></a>transmitter|[transfer::transmitter](tcllib/files/modules/transfer/transmitter\.md)|
|<a name='travelling\_salesman'></a>travelling salesman|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='traversal'></a>traversal|[fileutil\_traverse](tcllib/files/modules/fileutil/traverse\.md)|
|<a name='tree'></a>tree|[grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md) &#183; [grammar::me::util](tcllib/files/modules/grammar\_me/me\_util\.md) &#183; [htmlparse](tcllib/files/modules/htmlparse/htmlparse\.md) &#183; [struct::queue](tcllib/files/modules/struct/queue\.md) &#183; [struct::stack](tcllib/files/modules/struct/stack\.md) &#183; [struct::tree](tcllib/files/modules/struct/struct\_tree\.md) &#183; [struct::tree\_v1](tcllib/files/modules/struct/struct\_tree1\.md) &#183; [treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='tree\_query\_language'></a>tree query language|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='tree\_walking'></a>tree walking|[page\_util\_flow](tcllib/files/modules/page/page\_util\_flow\.md) &#183; [page\_util\_norm\_lemon](tcllib/files/modules/page/page\_util\_norm\_lemon\.md) &#183; [page\_util\_norm\_peg](tcllib/files/modules/page/page\_util\_norm\_peg\.md)|
|<a name='treeql'></a>TreeQL|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='trigonometry'></a>trigonometry|[math::trig](tcllib/files/modules/math/trig\.md)|
|<a name='trimming'></a>trimming|[textutil](tcllib/files/modules/textutil/textutil\.md) &#183; [textutil::trim](tcllib/files/modules/textutil/trim\.md)|
|<a name='twitter'></a>twitter|[oauth](tcllib/files/modules/oauth/oauth\.md)|
|<a name='type'></a>type|[fileutil](tcllib/files/modules/fileutil/fileutil\.md) &#183; [fileutil::magic::cfront](tcllib/files/modules/fumagic/cfront\.md) &#183; [fileutil::magic::cgen](tcllib/files/modules/fumagic/cgen\.md) &#183; [fileutil::magic::filetype](tcllib/files/modules/fumagic/filetypes\.md) &#183; [fileutil::magic::rt](tcllib/files/modules/fumagic/rtcore\.md) &#183; [snit](tcllib/files/modules/snit/snit\.md)|
|<a name='type\_checking'></a>Type checking|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|


#### <a name='cU'></a>Keywords: U

|||
|---|---|
|<a name='uevent'></a>uevent|[hook](tcllib/files/modules/hook/hook\.md)|
|<a name='unbind'></a>unbind|[uevent](tcllib/files/modules/uev/uevent\.md)|
|<a name='uncapitalize'></a>uncapitalize|[textutil::string](tcllib/files/modules/textutil/textutil\_string\.md)|
|<a name='undenting'></a>undenting|[textutil::adjust](tcllib/files/modules/textutil/adjust\.md)|
|<a name='unicode'></a>unicode|[stringprep](tcllib/files/modules/stringprep/stringprep\.md) &#183; [stringprep::data](tcllib/files/modules/stringprep/stringprep\_data\.md) &#183; [unicode](tcllib/files/modules/stringprep/unicode\.md) &#183; [unicode::data](tcllib/files/modules/stringprep/unicode\_data\.md)|
|<a name='unified\_format\_diff'></a>unified format diff|[textutil::patch](tcllib/files/modules/textutil/patch\.md)|
|<a name='union'></a>union|[struct::disjointset](tcllib/files/modules/struct/disjointset\.md) &#183; [struct::set](tcllib/files/modules/struct/struct\_set\.md)|
|<a name='unit'></a>unit|[units](tcllib/files/modules/units/units\.md)|
|<a name='unknown\_hooking'></a>unknown hooking|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='untie'></a>untie|[tie](tcllib/files/modules/tie/tie\_std\.md) &#183; [tie](tcllib/files/modules/tie/tie\.md)|
|<a name='update'></a>update|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md)|
|<a name='uri'></a>uri|[uri](tcllib/files/modules/uri/uri\.md) &#183; [uri\_urn](tcllib/files/modules/uri/urn\-scheme\.md)|
|<a name='url'></a>url|[doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::import](tcllib/files/modules/doctools2idx/idx\_import\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::import](tcllib/files/modules/doctools2toc/toc\_import\.md) &#183; [map::geocode::nominatim](tcllib/files/modules/map/map\_geocode\_nominatim\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md) &#183; [uri](tcllib/files/modules/uri/uri\.md) &#183; [uri\_urn](tcllib/files/modules/uri/urn\-scheme\.md)|
|<a name='urn'></a>urn|[uri\_urn](tcllib/files/modules/uri/urn\-scheme\.md)|
|<a name='us\_npi'></a>US\-NPI|[valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md)|
|<a name='utilities'></a>utilities|[namespacex](tcllib/files/modules/namespacex/namespacex\.md)|
|<a name='uuencode'></a>uuencode|[uuencode](tcllib/files/modules/base64/uuencode\.md)|
|<a name='uuid'></a>UUID|[uuid](tcllib/files/modules/uuid/uuid\.md)|


#### <a name='cV'></a>Keywords: V

|||
|---|---|
|<a name='validation'></a>Validation|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='value\_checking'></a>Value checking|[valtype::common](tcllib/files/modules/valtype/valtype\_common\.md) &#183; [valtype::creditcard::amex](tcllib/files/modules/valtype/cc\_amex\.md) &#183; [valtype::creditcard::discover](tcllib/files/modules/valtype/cc\_discover\.md) &#183; [valtype::creditcard::mastercard](tcllib/files/modules/valtype/cc\_mastercard\.md) &#183; [valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md) &#183; [valtype::gs1::ean13](tcllib/files/modules/valtype/ean13\.md) &#183; [valtype::iban](tcllib/files/modules/valtype/iban\.md) &#183; [valtype::imei](tcllib/files/modules/valtype/imei\.md) &#183; [valtype::isbn](tcllib/files/modules/valtype/isbn\.md) &#183; [valtype::luhn](tcllib/files/modules/valtype/luhn\.md) &#183; [valtype::luhn5](tcllib/files/modules/valtype/luhn5\.md) &#183; [valtype::usnpi](tcllib/files/modules/valtype/usnpi\.md) &#183; [valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='vectors'></a>vectors|[math::linearalgebra](tcllib/files/modules/math/linalg\.md)|
|<a name='verhoeff'></a>verhoeff|[valtype::verhoeff](tcllib/files/modules/valtype/verhoeff\.md)|
|<a name='vertex'></a>vertex|[struct::graph](tcllib/files/modules/struct/graph\.md) &#183; [struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='vertex\_cover'></a>vertex cover|[struct::graph::op](tcllib/files/modules/struct/graphops\.md)|
|<a name='virtual\_channel'></a>virtual channel|[tcl::chan::cat](tcllib/files/modules/virtchannel\_base/cat\.md) &#183; [tcl::chan::core](tcllib/files/modules/virtchannel\_core/core\.md) &#183; [tcl::chan::events](tcllib/files/modules/virtchannel\_core/events\.md) &#183; [tcl::chan::facade](tcllib/files/modules/virtchannel\_base/facade\.md) &#183; [tcl::chan::fifo](tcllib/files/modules/virtchannel\_base/tcllib\_fifo\.md) &#183; [tcl::chan::fifo2](tcllib/files/modules/virtchannel\_base/tcllib\_fifo2\.md) &#183; [tcl::chan::halfpipe](tcllib/files/modules/virtchannel\_base/halfpipe\.md) &#183; [tcl::chan::memchan](tcllib/files/modules/virtchannel\_base/tcllib\_memchan\.md) &#183; [tcl::chan::null](tcllib/files/modules/virtchannel\_base/tcllib\_null\.md) &#183; [tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md) &#183; [tcl::chan::random](tcllib/files/modules/virtchannel\_base/tcllib\_random\.md) &#183; [tcl::chan::std](tcllib/files/modules/virtchannel\_base/std\.md) &#183; [tcl::chan::string](tcllib/files/modules/virtchannel\_base/tcllib\_string\.md) &#183; [tcl::chan::textwindow](tcllib/files/modules/virtchannel\_base/textwindow\.md) &#183; [tcl::chan::variable](tcllib/files/modules/virtchannel\_base/tcllib\_variable\.md) &#183; [tcl::chan::zero](tcllib/files/modules/virtchannel\_base/tcllib\_zero\.md) &#183; [tcl::randomseed](tcllib/files/modules/virtchannel\_base/randseed\.md) &#183; [tcl::transform::adler32](tcllib/files/modules/virtchannel\_transform/adler32\.md) &#183; [tcl::transform::base64](tcllib/files/modules/virtchannel\_transform/vt\_base64\.md) &#183; [tcl::transform::core](tcllib/files/modules/virtchannel\_core/transformcore\.md) &#183; [tcl::transform::counter](tcllib/files/modules/virtchannel\_transform/vt\_counter\.md) &#183; [tcl::transform::crc32](tcllib/files/modules/virtchannel\_transform/vt\_crc32\.md) &#183; [tcl::transform::hex](tcllib/files/modules/virtchannel\_transform/hex\.md) &#183; [tcl::transform::identity](tcllib/files/modules/virtchannel\_transform/identity\.md) &#183; [tcl::transform::limitsize](tcllib/files/modules/virtchannel\_transform/limitsize\.md) &#183; [tcl::transform::observe](tcllib/files/modules/virtchannel\_transform/observe\.md) &#183; [tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md) &#183; [tcl::transform::rot](tcllib/files/modules/virtchannel\_transform/rot\.md) &#183; [tcl::transform::spacer](tcllib/files/modules/virtchannel\_transform/spacer\.md) &#183; [tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='virtual\_machine'></a>virtual machine|[grammar::me::cpu](tcllib/files/modules/grammar\_me/me\_cpu\.md) &#183; [grammar::me::cpu::core](tcllib/files/modules/grammar\_me/me\_cpucore\.md) &#183; [grammar::me::cpu::gasm](tcllib/files/modules/grammar\_me/gasm\.md) &#183; [grammar::me::tcl](tcllib/files/modules/grammar\_me/me\_tcl\.md) &#183; [grammar::me\_intro](tcllib/files/modules/grammar\_me/me\_intro\.md) &#183; [grammar::me\_vm](tcllib/files/modules/grammar\_me/me\_vm\.md) &#183; [grammar::peg::interp](tcllib/files/modules/grammar\_peg/peg\_interp\.md) &#183; [pt::param](tcllib/files/modules/pt/pt\_param\.md)|
|<a name='visa'></a>VISA|[valtype::creditcard::visa](tcllib/files/modules/valtype/cc\_visa\.md)|
|<a name='vwait'></a>vwait|[coroutine](tcllib/files/modules/coroutine/tcllib\_coroutine\.md) &#183; [coroutine::auto](tcllib/files/modules/coroutine/coro\_auto\.md) &#183; [smtpd](tcllib/files/modules/smtpd/smtpd\.md)|


#### <a name='cW'></a>Keywords: W

|||
|---|---|
|<a name='wais'></a>wais|[uri](tcllib/files/modules/uri/uri\.md)|
|<a name='widget'></a>widget|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|
|<a name='widget\_adaptors'></a>widget adaptors|[snit](tcllib/files/modules/snit/snit\.md) &#183; [snitfaq](tcllib/files/modules/snit/snitfaq\.md)|
|<a name='wiki'></a>wiki|[doctools::idx](tcllib/files/modules/doctools/docidx\.md) &#183; [doctools::idx](tcllib/files/modules/doctools2idx/idx\_container\.md) &#183; [doctools::idx::export](tcllib/files/modules/doctools2idx/idx\_export\.md) &#183; [doctools::idx::export::wiki](tcllib/files/modules/doctools2idx/idx\_export\_wiki\.md) &#183; [doctools::toc](tcllib/files/modules/doctools2toc/toc\_container\.md) &#183; [doctools::toc](tcllib/files/modules/doctools/doctoc\.md) &#183; [doctools::toc::export](tcllib/files/modules/doctools2toc/toc\_export\.md) &#183; [doctools::toc::export::wiki](tcllib/files/modules/doctools2toc/toc\_export\_wiki\.md)|
|<a name='word'></a>word|[doctools::tcl::parse](tcllib/files/modules/doctools2base/tcl\_parse\.md) &#183; [wip](tcllib/files/modules/wip/wip\.md)|
|<a name='www'></a>WWW|[httpd](tcllib/files/modules/httpd/httpd\.md)|
|<a name='www'></a>www|[uri](tcllib/files/modules/uri/uri\.md)|


#### <a name='cX'></a>Keywords: X

|||
|---|---|
|<a name='x\_208'></a>x\.208|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='x\_209'></a>x\.209|[asn](tcllib/files/modules/asn/asn\.md)|
|<a name='x\_500'></a>x\.500|[ldap](tcllib/files/modules/ldap/ldap\.md)|
|<a name='xgoogletoken'></a>XGoogleToken|[SASL::XGoogleToken](tcllib/files/modules/sasl/gtoken\.md)|
|<a name='xml'></a>xml|[xsxp](tcllib/files/modules/amazon\-s3/xsxp\.md)|
|<a name='xor'></a>xor|[tcl::transform::otp](tcllib/files/modules/virtchannel\_transform/vt\_otp\.md)|
|<a name='xpath'></a>XPath|[treeql](tcllib/files/modules/treeql/treeql\.md)|
|<a name='xslt'></a>XSLT|[treeql](tcllib/files/modules/treeql/treeql\.md)|


#### <a name='cY'></a>Keywords: Y

|||
|---|---|
|<a name='yaml'></a>yaml|[huddle](tcllib/files/modules/yaml/huddle\.md) &#183; [yaml](tcllib/files/modules/yaml/yaml\.md)|
|<a name='ydecode'></a>ydecode|[yencode](tcllib/files/modules/base64/yencode\.md)|
|<a name='yenc'></a>yEnc|[yencode](tcllib/files/modules/base64/yencode\.md)|
|<a name='yencode'></a>yencode|[yencode](tcllib/files/modules/base64/yencode\.md)|


#### <a name='cZ'></a>Keywords: Z

|||
|---|---|
|<a name='zero'></a>zero|[tcl::chan::nullzero](tcllib/files/modules/virtchannel\_base/nullzero\.md) &#183; [tcl::chan::zero](tcllib/files/modules/virtchannel\_base/tcllib\_zero\.md)|
|<a name='zip'></a>zip|[zipfile::decode](tcllib/files/modules/zip/decode\.md) &#183; [zipfile::encode](tcllib/files/modules/zip/encode\.md) &#183; [zipfile::mkzip](tcllib/files/modules/zip/mkzip\.md)|
|<a name='zlib'></a>zlib|[tcl::transform::zlib](tcllib/files/modules/virtchannel\_transform/tcllib\_zlib\.md)|
|<a name='zoom'></a>zoom|[map::slippy](tcllib/files/modules/map/map\_slippy\.md) &#183; [map::slippy::cache](tcllib/files/modules/map/map\_slippy\_cache\.md) &#183; [map::slippy::fetcher](tcllib/files/modules/map/map\_slippy\_fetcher\.md)|
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/apps/dtplite.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408

[//000000001]: # (dtplite \- Documentation toolbox)
[//000000002]: # (Generated from file 'dtplite\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2004\-2013 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (dtplite\(n\) 1\.0\.5 tcllib "Documentation toolbox")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

dtplite \- Lightweight DocTools Markup Processor

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [USE CASES](#subsection1)

      - [COMMAND LINE](#subsection2)

      - [OPTIONS](#subsection3)

      - [FORMATS](#subsection4)

      - [DIRECTORY STRUCTURES](#subsection5)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__dtplite__ __\-o__ *output* ?options? *format* *inputfile*](#1)  
[__dtplite__ __validate__ *inputfile*](#2)  
[__dtplite__ __\-o__ *output* ?options? *format* *inputdirectory*](#3)  
[__dtplite__ __\-merge__ __\-o__ *output* ?options? *format* *inputdirectory*](#4)  

# <a name='description'></a>DESCRIPTION

The application described by this document, __dtplite__, is the successor to
the extremely simple __[mpexpand](\.\./modules/doctools/mpexpand\.md)__\.
Influenced in its functionality by the __dtp__ doctools processor it is much
more powerful than __[mpexpand](\.\./modules/doctools/mpexpand\.md)__, yet
still as easy to use; definitely easier than __dtp__ with its myriad of
subcommands and options\.

__dtplite__ is based upon the package
__[doctools](\.\./modules/doctools/doctools\.md)__, like the other two
processors\.

## <a name='subsection1'></a>USE CASES

__dtplite__ was written with the following three use cases in mind\.

  1. Validation of a single document, i\.e\. checking that it was written in valid
     doctools format\. This mode can also be used to get a preliminary version of
     the formatted output for a single document, for display in a browser,
     nroff, etc\., allowing proofreading of the formatting\.

  1. Generation of the formatted documentation for a single package, i\.e\. all
     the manpages, plus a table of contents and an index of keywords\.

  1. An extension of the previous mode of operation, a method for the easy
     generation of one documentation tree for several packages, and especially
     of a unified table of contents and keyword index\.

Beyond the above we also want to make use of the customization features provided
by the HTML formatter\. It is not the only format the application should be able
to generate, but we anticipiate it to be the most commonly used, and it is one
of the few which do provide customization hooks\.

We allow the caller to specify a header string, footer string, a stylesheet, and
data for a bar of navigation links at the top of the generated document\. While
all can be set as long as the formatting engine provides an appropriate engine
parameter \(See section [OPTIONS](#subsection3)\) the last two have internal
processing which make them specific to HTML\.

## <a name='subsection2'></a>COMMAND LINE

  - <a name='1'></a>__dtplite__ __\-o__ *output* ?options? *format* *inputfile*

    This is the form for use case \[1\]\. The *options* will be explained later,
    in section [OPTIONS](#subsection3)\.

      * path *output* \(in\)

        This argument specifies where to write the generated document\. It can be
        the path to a file or directory, or __\-__\. The last value causes the
        application to write the generated documented to __stdout__\.

        If the *output* does not exist then \[file dirname $output\] has to
        exist and must be a writable directory\. The generated document will be
        written to a file in that directory, and the name of that file will be
        derived from the *inputfile*, the *format*, and the value given to
        option __\-ext__ \(if present\)\.

      * \(path&#124;handle\) *format* \(in\)

        This argument specifies the formatting engine to use when processing the
        input, and thus the format of the generated document\. See section
        [FORMATS](#subsection4) for the possibilities recognized by the
        application\.

      * path *inputfile* \(in\)

        This argument specifies the path to the file to process\. It has to
        exist, must be readable, and written in
        *[doctools](\.\./\.\./\.\./index\.md\#doctools)* format\.

  - <a name='2'></a>__dtplite__ __validate__ *inputfile*

    This is a simpler form for use case \[1\]\. The "validate" format generates no
    output at all, only syntax checks are performed\. As such the specification
    of an output file or other options is not necessary and left out\.

  - <a name='3'></a>__dtplite__ __\-o__ *output* ?options? *format* *inputdirectory*

    This is the form for use case \[2\]\. It differs from the form for use case \[1\]
    by having the input documents specified through a directory instead of a
    file\. The other arguments are identical, except for *output*, which now
    has to be the path to an existing and writable directory\.

    The input documents are all files in *inputdirectory* or any of its
    subdirectories which were recognized by __fileutil::fileType__ as
    containing text in *[doctools](\.\./\.\./\.\./index\.md\#doctools)* format\.

  - <a name='4'></a>__dtplite__ __\-merge__ __\-o__ *output* ?options? *format* *inputdirectory*

    This is the form for use case \[3\]\. The only difference to the form for use
    case \[2\] is the additional option __\-merge__\.

    Each such call will merge the generated documents coming from processing the
    input documents under *inputdirectory* or any of its subdirectories to the
    files under *output*\. In this manner it is possible to incrementally build
    the unified documentation for any number of packages\. Note that it is
    necessary to run through all the packages twice to get fully correct
    cross\-references \(for formats supporting them\)\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application,
with the exception of the options __\-o__ and __\-merge__\. These two were
described already, in section [COMMAND LINE](#subsection2)\.

  - __\-exclude__ string

    This option specifies an exclude \(glob\) pattern\. Any files identified as
    manpages to process which match the exclude pattern are ignored\. The option
    can be provided multiple times, each usage adding an additional pattern to
    the list of exclusions\.

  - __\-ext__ string

    If the name of an output file has to be derived from the name of an input
    file it will use the name of the *format* as the extension by default\.
    This option here will override this however, forcing it to use *string* as
    the file extension\. This option is ignored if the name of the output file is
    fully specified through option __\-o__\.

    When used multiple times only the last definition is relevant\.

  - __\-header__ file

    This option can be used if and only if the selected *format* provides an
    engine parameter named "header"\. It takes the contents of the specified file
    and assign them to that parameter, for whatever use by the engine\. The HTML
    engine will insert the text just after the tag __<body>__\. If navigation
    buttons are present \(see option __\-nav__ below\), then the HTML generated
    for them is appended to the header data originating here before the final
    assignment to the parameter\.

    When used multiple times only the last definition is relevant\.

  - __\-footer__ file

    Like __\-header__, except that: Any navigation buttons are ignored, the
    corresponding required engine parameter is named "footer", and the data is
    inserted just before the tag __</body>__\.

    When used multiple times only the last definition is relevant\.

  - __\-style__ file

    This option can be used if and only if the selected *format* provides an
    engine parameter named "meta"\. When specified it will generate a piece of
    HTML code declaring the *file* as the stylesheet for the generated
    document and assign that to the parameter\. The HTML engine will insert this
    inot the document, just after the tag __<head>__\.

    When processing an input directory the stylesheet file is copied into the
    output directory and the generated HTML will refer to the copy, to make the
    result more self\-contained\. When processing an input file we have no
    location to copy the stylesheet to and so just reference it as specified\.

    When used multiple times only the last definition is relevant\.

  - __\-toc__ path

    This option specifies a doctoc file to use for the table of contents instead
    of generating our own\.

    When used multiple times only the last definition is relevant\.

  - __\-pre\+toc__ label path&#124;text

  - __\-post\+toc__ label path&#124;text

    This option specifies additional doctoc files \(or texts\) to use in the
    navigation bar\.

    Positioning and handling of multiple uses is like for options
    __\-prenav__ and __\-postnav__, see below\.

  - __\-nav__ label url

  - __\-prenav__ label url

    Use this option to specify a navigation button with *label* to display and
    the *url* to link to\. This option can be used if and only if the selected
    *format* provides an engine parameter named "header"\. The HTML generated
    for this is appended to whatever data we got from option __\-header__
    before it is inserted into the generated documents\.

    When used multiple times all definitions are collected and a navigation bar
    is created, with the first definition shown at the left edge and the last
    definition to the right\.

    The url can be relative\. In that case it is assumed to be relative to the
    main files \(TOC and Keyword index\), and will be transformed for all others
    to still link properly\.

  - __\-postnav__ label url

    Use this option to specify a navigation button with *label* to display and
    the *url* to link to\. This option can be used if and only if the selected
    *format* provides an engine parameter named "header"\. The HTML generated
    for this is appended to whatever data we got from option __\-header__
    before it is inserted into the generated documents\.

    When used multiple times all definitions are collected and a navigation bar
    is created, with the last definition shown at the right edge and the first
    definition to the left\.

    The url can be relative\. In that case it is assumed to be relative to the
    main files \(TOC and Keyword index\), and will be transformed for all others
    to still link properly\.

## <a name='subsection4'></a>FORMATS

At first the *format* argument will be treated as a path to a tcl file
containing the code for the requested formatting engine\. The argument will be
treated as the name of one of the predefined formats listed below if and only if
the path does not exist\.

*Note a limitation*: If treating the format as path to the tcl script
implementing the engine was sucessful, then this script has to implement not
only the engine API for doctools, i\.e\. *doctools\_api*, but for *doctoc\_api*
and *docidx\_api* as well\. Otherwise the generation of a table of contents and
of a keyword index will fail\.

List of predefined formats, i\.e\. as provided by the package
__[doctools](\.\./modules/doctools/doctools\.md)__:

  - __nroff__

    The processor generates \*roff output, the standard format for unix manpages\.

  - __html__

    The processor generates HTML output, for usage in and display by web
    browsers\. This engine is currently the only one providing the various engine
    parameters required for the additional customaization of the output\.

  - __tmml__

    The processor generates TMML output, the Tcl Manpage Markup Language, a
    derivative of XML\.

  - __latex__

    The processor generates LaTeX output\.

  - __wiki__

    The processor generates Wiki markup as understood by __wikit__\.

  - __list__

    The processor extracts the information provided by __manpage\_begin__\.
    This format is used internally to extract the meta data from which both
    table of contents and keyword index are derived from\.

  - __null__

    The processor does not generate any output\. This is equivalent to
    __validate__\.

## <a name='subsection5'></a>DIRECTORY STRUCTURES

In this section we describe the directory structures generated by the
application under *output* when processing all documents in an
*inputdirectory*\. In other words, this is only relevant to the use cases \[2\]
and \[3\]\.

  - \[2\]

    The following directory structure is created when processing a single set of
    input documents\. The file extension used is for output in HTML, but that is
    not relevant to the structure and was just used to have proper file names\.

        output/
            toc.html
            index.html
            files/
                path/to/FOO.html

    The last line in the example shows the document generated for a file FOO
    located at

        inputdirectory/path/to/FOO

  - \[3\]

    When merging many packages into a unified set of documents the generated
    directory structure is a bit deeper:

        output
            .toc
            .idx
            .tocdoc
            .idxdoc
            .xrf
            toc.html
            index.html
            FOO1/
                ...
            FOO2/
                toc.html
                files/
                    path/to/BAR.html

    Each of the directories FOO1, \.\.\. contains the documents generated for the
    package FOO1, \.\.\. and follows the structure shown for use case \[2\]\. The only
    exception is that there is no per\-package index\.

    The files "\.toc", "\.idx", and "\.xrf" contain the internal status of the
    whole output and will be read and updated by the next invokation\. Their
    contents will not be documented\. Remove these files when all packages wanted
    for the output have been processed, i\.e\. when the output is complete\.

    The files "\.tocdoc", and "\.idxdoc", are intermediate files in doctoc and
    docidx markup, respectively, containing the main table of contents and
    keyword index for the set of documents before their conversion to the chosen
    output format\. They are left in place, i\.e\. not deleted, to serve as
    demonstrations of doctoc and docidx markup\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *doctools* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[docidx introduction](\.\./modules/doctools/docidx\_intro\.md), [doctoc
introduction](\.\./modules/doctools/doctoc\_intro\.md), [doctools
introduction](\.\./modules/doctools/doctools\_intro\.md)

# <a name='keywords'></a>KEYWORDS

[HTML](\.\./\.\./\.\./index\.md\#html), [TMML](\.\./\.\./\.\./index\.md\#tmml),
[conversion](\.\./\.\./\.\./index\.md\#conversion),
[docidx](\.\./\.\./\.\./index\.md\#docidx), [doctoc](\.\./\.\./\.\./index\.md\#doctoc),
[doctools](\.\./\.\./\.\./index\.md\#doctools),
[manpage](\.\./\.\./\.\./index\.md\#manpage),
[markup](\.\./\.\./\.\./index\.md\#markup), [nroff](\.\./\.\./\.\./index\.md\#nroff)

# <a name='category'></a>CATEGORY

Documentation tools

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2004\-2013 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
















































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/apps/nns.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

[//000000001]: # (nns \- Name service facility)
[//000000002]: # (Generated from file 'nns\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2007\-2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (nns\(n\) 1\.1 tcllib "Name service facility")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

nns \- Name service facility, Commandline Client Application

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [USE CASES](#subsection1)

      - [COMMAND LINE](#subsection2)

      - [OPTIONS](#subsection3)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__nns__ __bind__ ?__\-host__ *host*? ?__\-port__ *port*? *name* *data*](#1)  
[__nns__ __search__ ?__\-host__ *host*? ?__\-port__ *port*? ?__\-continuous__? ?*pattern*?](#2)  
[__nns__ __ident__ ?__\-host__ *host*? ?__\-port__ *port*?](#3)  
[__nns__ __who__](#4)  

# <a name='description'></a>DESCRIPTION

Please read *[Name service facility,
introduction](\.\./modules/nns/nns\_intro\.md)* first\.

The application described by this document, __nns__, is a simple command
line client for the nano name service facility provided by the Tcllib packages
__[nameserv](\.\./modules/nns/nns\_client\.md)__, and
__[nameserv::server](\.\./modules/nns/nns\_server\.md)__\. Beyond that the
application's sources also serve as an example of how to use the client package
__[nameserv](\.\./modules/nns/nns\_client\.md)__\. All abilities of a client
are covered, from configuration to registration of names to searching\.

This name service facility has nothing to do with the Internet's *Domain Name
System*, otherwise known as *[DNS](\.\./\.\./\.\./index\.md\#dns)*\. If the reader
is looking for a package dealing with that please see either of the packages
__[dns](\.\./modules/dns/tcllib\_dns\.md)__ and __resolv__, both found
in Tcllib too\.

## <a name='subsection1'></a>USE CASES

__nns__ was written with the following two main use cases in mind\.

  1. Registration of a name/data pair in the name service\.

  1. Searching the name service for entries matching a glob pattern\.

Beyond the above we also want to be able to identify the client, and get
information about the name service\.

## <a name='subsection2'></a>COMMAND LINE

  - <a name='1'></a>__nns__ __bind__ ?__\-host__ *host*? ?__\-port__ *port*? *name* *data*

    This form registers the *name*/*data* pair in the specified name
    service\. In this form the command will *not* exit to keep the registration
    alive\. The user has to kill it explicitly, either by sending a signal, or
    through the job\-control facilities of the shell in use\. It will especially
    survive the loss of the connection to the name service and reestablish the
    *name*/*data* pair when the connection is restored\.

    The options to specify the name service will be explained later, in section
    [OPTIONS](#subsection3)\.

  - <a name='2'></a>__nns__ __search__ ?__\-host__ *host*? ?__\-port__ *port*? ?__\-continuous__? ?*pattern*?

    This form searches the specified name service for entries matching the
    glob\-*pattern* and prints them to stdout, with each entry on its own line\.
    If no pattern is specified it defaults to __\*__, matching everything\.

    The options to specify the name service will be explained later, in section
    [OPTIONS](#subsection3)\.

    If the option __\-continuous__ is specified the client will not exit
    after performing the search, but start to continuously monitor the service
    for changes to the set of matching entries, appropriately updating the
    display as changes arrive\. In that form it will especially also survive the
    loss of the connection to the name service and reestablish the search when
    the connection is restored\.

  - <a name='3'></a>__nns__ __ident__ ?__\-host__ *host*? ?__\-port__ *port*?

    This form asks the specified name service for the version and features of
    the name service protocol it supports and prints the results to stdout\.

    The options to specify the name service will be explained later, in section
    [OPTIONS](#subsection3)\.

  - <a name='4'></a>__nns__ __who__

    This form prints name, version, and protocol version of the application to
    stdout\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application

  - __\-host__ name&#124;ipaddress

    If this option is not specified it defaults to __localhost__\. It
    specifies the name or ip\-address of the host the name service to talk to is
    running on\.

  - __\-port__ number

    If this option is not specified it defaults to __38573__\. It specifies
    the TCP port the name service to talk to is listening on for requests\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *nameserv* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[nameserv\(n\)](\.\./modules/nns/nns\_client\.md),
[nameserv::common\(n\)](\.\./modules/nns/nns\_common\.md)

# <a name='keywords'></a>KEYWORDS

[application](\.\./\.\./\.\./index\.md\#application),
[client](\.\./\.\./\.\./index\.md\#client), [name
service](\.\./\.\./\.\./index\.md\#name\_service)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2007\-2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


















































































































































































































































































































































Deleted embedded/md/tcllib/files/apps/nnsd.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

[//000000001]: # (nnsd \- Name service facility)
[//000000002]: # (Generated from file 'nnsd\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2007\-2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (nnsd\(n\) 1\.0\.1 tcllib "Name service facility")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

nnsd \- Name service facility, Commandline Server Application

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [USE CASES](#subsection1)

      - [COMMAND LINE](#subsection2)

      - [OPTIONS](#subsection3)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__nnsd__ ?__\-localonly__ *flag*? ?__\-port__ *port*?](#1)  

# <a name='description'></a>DESCRIPTION

Please read *[Name service facility,
introduction](\.\./modules/nns/nns\_intro\.md)* first\.

The application described by this document, __[nns](nns\.md)__, is a
simple command line server for the nano name service facility provided by the
Tcllib packages __[nameserv](\.\./modules/nns/nns\_client\.md)__, and
__[nameserv::server](\.\./modules/nns/nns\_server\.md)__\. Beyond that the
application's sources also serve as an example of how to use the server package
__[nameserv::server](\.\./modules/nns/nns\_server\.md)__\.

This name service facility has nothing to do with the Internet's *Domain Name
System*, otherwise known as *[DNS](\.\./\.\./\.\./index\.md\#dns)*\. If the reader
is looking for a package dealing with that please see either of the packages
__[dns](\.\./modules/dns/tcllib\_dns\.md)__ and __resolv__, both found
in Tcllib too\.

## <a name='subsection1'></a>USE CASES

__nnsd__ was written with the following main use case in mind\.

  1. Run a nano name service on some host\.

## <a name='subsection2'></a>COMMAND LINE

  - <a name='1'></a>__nnsd__ ?__\-localonly__ *flag*? ?__\-port__ *port*?

    The command configures a server per the specified options and starts it\. The
    command will not exit on its own, as it keeps the name service database
    wholly in memory\. The user has to kill it explicitly, either by sending a a
    signal, or through the job\-control facilities of the shell in use\.

    The options to configure the name service are explained in section
    [OPTIONS](#subsection3)\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application

  - __\-localonly__ bool

    If this option is not specified it defaults to __true__, i\.e\. acceptance
    of only local connections\. The server will accept remote connections, i\.e\.
    connections from other hosts, if and only if this option is configured to
    __false__\.

  - __\-port__ number

    If this option is not specified it defaults to __38573__\. It specifies
    the TCP port the server has to listen on for requests\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *nameserv* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[nameserv::common\(n\)](\.\./modules/nns/nns\_common\.md),
[nameserv::server\(n\)](\.\./modules/nns/nns\_server\.md)

# <a name='keywords'></a>KEYWORDS

[application](\.\./\.\./\.\./index\.md\#application), [name
service](\.\./\.\./\.\./index\.md\#name\_service),
[server](\.\./\.\./\.\./index\.md\#server)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2007\-2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































































































































































































































































Deleted embedded/md/tcllib/files/apps/nnslog.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

[//000000001]: # (nnslog \- Name service facility)
[//000000002]: # (Generated from file 'nnslog\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (nnslog\(n\) 1\.0 tcllib "Name service facility")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

nnslog \- Name service facility, Commandline Logging Client Application

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [USE CASES](#subsection1)

      - [COMMAND LINE](#subsection2)

      - [OPTIONS](#subsection3)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__nnslog__ ?__\-host__ *host*? ?__\-port__ *port*?](#1)  

# <a name='description'></a>DESCRIPTION

Please read *[Name service facility,
introduction](\.\./modules/nns/nns\_intro\.md)* first\.

The application described by this document, __nnslog__, is a simple command
line client for the nano name service facility provided by the Tcllib packages
__[nameserv](\.\./modules/nns/nns\_client\.md)__, and
__[nameserv::server](\.\./modules/nns/nns\_server\.md)__\.

It essentially implements "__[nns](nns\.md)__ search \-continuous \*", but
uses a different output formatting\. Instead of continuously showing the current
contents of the server in the terminal it simply logs all received add/remove
events to __stdout__\.

This name service facility has nothing to do with the Internet's *Domain Name
System*, otherwise known as *[DNS](\.\./\.\./\.\./index\.md\#dns)*\. If the reader
is looking for a package dealing with that please see either of the packages
__[dns](\.\./modules/dns/tcllib\_dns\.md)__ and __resolv__, both found
in Tcllib too\.

## <a name='subsection1'></a>USE CASES

__nnslog__ was written with the following main use case in mind\.

  1. Monitoring the name service for all changes and logging them in a text
     terminal\.

## <a name='subsection2'></a>COMMAND LINE

  - <a name='1'></a>__nnslog__ ?__\-host__ *host*? ?__\-port__ *port*?

    The command connects to the specified name service, sets up a search for all
    changes and then prints all received events to stdout, with each events on
    its own line\. The command will not exit until it is explicitly terminated by
    the user\. It will especially survive the loss of the connection to the name
    service and reestablish the search and log when the connection is restored\.

    The options to specify the name service will be explained later, in section
    [OPTIONS](#subsection3)\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application

  - __\-host__ name&#124;ipaddress

    If this option is not specified it defaults to __localhost__\. It
    specifies the name or ip\-address of the host the name service to talk to is
    running on\.

  - __\-port__ number

    If this option is not specified it defaults to __38573__\. It specifies
    the TCP port the name service to talk to is listening on for requests\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *nameserv* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[nameserv\(n\)](\.\./modules/nns/nns\_client\.md),
[nameserv::common\(n\)](\.\./modules/nns/nns\_common\.md)

# <a name='keywords'></a>KEYWORDS

[application](\.\./\.\./\.\./index\.md\#application),
[client](\.\./\.\./\.\./index\.md\#client), [name
service](\.\./\.\./\.\./index\.md\#name\_service)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<












































































































































































































































































Deleted embedded/md/tcllib/files/apps/page.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474

[//000000001]: # (page \- Development Tools)
[//000000002]: # (Generated from file 'page\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (page\(n\) 1\.0 tcllib "Development Tools")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

page \- Parser Generator

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [COMMAND LINE](#subsection1)

      - [OPERATION](#subsection2)

      - [OPTIONS](#subsection3)

      - [PLUGINS](#subsection4)

      - [PLUGIN LOCATIONS](#subsection5)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__page__ ?*options*\.\.\.? ?*input* ?*output*??](#1)  

# <a name='description'></a>DESCRIPTION

The application described by this document, __page__, is actually not just a
parser generator, as the name implies, but a generic tool for the execution of
arbitrary transformations on texts\.

Its genericity comes through the use of *plugins* for reading, transforming,
and writing data, and the predefined set of plugins provided by Tcllib is for
the generation of memoizing recursive descent parsers \(aka *packrat parsers*\)
from grammar specifications \(*Parsing Expression Grammars*\)\.

__page__ is written on top of the package __page::pluginmgr__, wrapping
its functionality into a command line based application\. All the other
__page::\*__ packages are plugin and/or supporting packages for the
generation of parsers\. The parsers themselves are based on the packages
__[grammar::peg](\.\./modules/grammar\_peg/peg\.md)__,
__[grammar::peg::interp](\.\./modules/grammar\_peg/peg\_interp\.md)__, and
__grammar::mengine__\.

## <a name='subsection1'></a>COMMAND LINE

  - <a name='1'></a>__page__ ?*options*\.\.\.? ?*input* ?*output*??

    This is general form for calling __page__\. The application will read the
    contents of the file *input*, process them under the control of the
    specified *options*, and then write the result to the file *output*\.

    If *input* is the string __\-__ the data to process will be read from
    __stdin__ instead of a file\. Analogously the result will be written to
    __stdout__ instead of a file if *output* is the string __\-__\. A
    missing output or input specification causes the application to assume
    __\-__\.

    The detailed specifications of the recognized *options* are provided in
    section [OPTIONS](#subsection3)\.

      * path *input* \(in\)

        This argument specifies the path to the file to be processed by the
        application, or __\-__\. The last value causes the application to read
        the text from __stdin__\. Otherwise it has to exist, and be readable\.
        If the argument is missing __\-__ is assumed\.

      * path *output* \(in\)

        This argument specifies where to write the generated text\. It can be the
        path to a file, or __\-__\. The last value causes the application to
        write the generated documented to __stdout__\.

        If the file *output* does not exist then \[file dirname $output\] has to
        exist and must be a writable directory, as the application will create
        the fileto write to\.

        If the argument is missing __\-__ is assumed\.

## <a name='subsection2'></a>OPERATION

\.\.\. reading \.\.\. transforming \.\.\. writing \- plugins \- pipeline \.\.\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application\.
Options are always processed in order\. I\.e\. of both __\-\-help__ and
__\-\-version__ are specified the option encountered first has precedence\.

Unknown options specified before any of the options __\-rd__, __\-wr__, or
__\-tr__ will cause processing to abort with an error\. Unknown options coming
in between these options, or after the last of them are assumed to always take a
single argument and are associated with the last plugin option coming before
them\. They will be checked after all the relevant plugins, and thus the options
they understand, are known\. I\.e\. such unknown options cause error if and only if
the plugin option they are associated with does not understand them, and was not
superceded by a plugin option coming after\.

Default options are used if and only if the command line did not contain any
options at all\. They will set the application up as a PEG\-based parser
generator\. The exact list of options is

    -c peg

And now the recognized options and their arguments, if they have any:

  - __\-\-help__

  - __\-h__

  - __\-?__

    When one of these options is found on the command line all arguments coming
    before or after are ignored\. The application will print a short description
    of the recognized options and exit\.

  - __\-\-version__

  - __\-V__

    When one of these options is found on the command line all arguments coming
    before or after are ignored\. The application will print its own revision and
    exit\.

  - __\-P__

    This option signals the application to activate visual feedback while
    reading the input\.

  - __\-T__

    This option signals the application to collect statistics while reading the
    input and to print them after reading has completed, before processing
    started\.

  - __\-D__

    This option signals the application to activate logging in the Safe base,
    for the debugging of problems with plugins\.

  - __\-r__ parser

  - __\-rd__ parser

  - __\-\-reader__ parser

    These options specify the plugin the application has to use for reading the
    *input*\. If the options are used multiple times the last one will be used\.

  - __\-w__ generator

  - __\-wr__ generator

  - __\-\-writer__ generator

    These options specify the plugin the application has to use for generating
    and writing the final *output*\. If the options are used multiple times the
    last one will be used\.

  - __\-t__ process

  - __\-tr__ process

  - __\-\-transform__ process

    These options specify a plugin to run on the input\. In contrast to readers
    and writers each use will *not* supersede previous uses, but add each
    chosen plugin to a list of transformations, either at the front, or the end,
    per the last seen use of either option __\-p__ or __\-a__\. The initial
    default is to append the new transformations\.

  - __\-a__

  - __\-\-append__

    These options signal the application that all following transformations
    should be added at the end of the list of transformations\.

  - __\-p__

  - __\-\-prepend__

    These options signal the application that all following transformations
    should be added at the beginning of the list of transformations\.

  - __\-\-reset__

    This option signals the application to clear the list of transformations\.
    This is necessary to wipe out the default transformations used\.

  - __\-c__ file

  - __\-\-configuration__ file

    This option causes the application to load a configuration file and/or
    plugin\. This is a plugin which in essence provides a pre\-defined set of
    commandline options\. They are processed exactly as if they have been
    specified in place of the option and its arguments\. This means that unknown
    options found at the beginning of the configuration file are associated with
    the last plugin, even if that plugin was specified before the configuration
    file itself\. Conversely, unknown options coming after the configuration file
    can be associated with a plugin specified in the file\.

    If the argument is a file which cannot be loaded as a plugin the application
    will assume that its contents are a list of options and their arguments,
    separated by space, tabs, and newlines\. Options and argumentes containing
    spaces can be quoted via double\-quotes \("\) and quotes \('\)\. The quote
    character can be specified within in a quoted string by doubling it\.
    Newlines in a quoted string are accepted as is\.

## <a name='subsection4'></a>PLUGINS

__page__ makes use of four different types of plugins, namely: readers,
writers, transformations, and configurations\. Here we provide only a basic
introduction on how to use them from __page__\. The exact APIs provided to
and expected from the plugins can be found in the documentation for
__page::pluginmgr__, for those who wish to write their own plugins\.

Plugins are specified as arguments to the options __\-r__, __\-w__,
__\-t__, __\-c__, and their equivalent longer forms\. See the section
[OPTIONS](#subsection3) for reference\.

Each such argument will be first treated as the name of a file and this file is
loaded as the plugin\. If however there is no file with that name, then it will
be translated into the name of a package, and this package is then loaded\. For
each type of plugins the package management searches not only the regular paths,
but a set application\- and type\-specific paths as well\. Please see the section
[PLUGIN LOCATIONS](#subsection5) for a listing of all paths and their
sources\.

  - __\-c__ *name*

    Configurations\. The name of the package for the plugin *name* is
    "page::config::*name*"\.

    We have one predefined plugin:

      * *peg*

        It sets the application up as a parser generator accepting parsing
        expression grammars and writing a packrat parser in Tcl\. The actual
        arguments it specifies are:

    --reset
    --append
    --reader    peg
    --transform reach
    --transform use
    --writer    me

  - __\-r__ *name*

    Readers\. The name of the package for the plugin *name* is
    "page::reader::*name*"\.

    We have five predefined plugins:

      * *peg*

        Interprets the input as a parsing expression grammar
        \(*[PEG](\.\./\.\./\.\./index\.md\#peg)*\) and generates a tree
        representation for it\. Both the syntax of PEGs and the structure of the
        tree representation are explained in their own manpages\.

      * *hb*

        Interprets the input as Tcl code as generated by the writer plugin
        *hb* and generates its tree representation\.

      * *ser*

        Interprets the input as the serialization of a PEG, as generated by the
        writer plugin *ser*, using the package
        __[grammar::peg](\.\./modules/grammar\_peg/peg\.md)__\.

      * *lemon*

        Interprets the input as a grammar specification as understood by Richard
        Hipp's *[LEMON](\.\./\.\./\.\./index\.md\#lemon)* parser generator and
        generates a tree representation for it\. Both the input syntax and the
        structure of the tree representation are explained in their own
        manpages\.

      * *treeser*

        Interprets the input as the serialization of a
        __[struct::tree](\.\./modules/struct/struct\_tree\.md)__\. It is
        validated as such, but nothing else\. It is *not* assumed to be the
        tree representation of a grammar\.

  - __\-w__ *name*

    Writers\. The name of the package for the plugin *name* is
    "page::writer::*name*"\.

    We have eight predefined plugins:

      * *identity*

        Simply writes the incoming data as it is, without making any changes\.
        This is good for inspecting the raw result of a reader or
        transformation\.

      * *null*

        Generates nothing, and ignores the incoming data structure\.

      * *tree*

        Assumes that the incoming data structure is a
        __[struct::tree](\.\./modules/struct/struct\_tree\.md)__ and
        generates an indented textual representation of all nodes, their
        parental relationships, and their attribute information\.

      * *peg*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar and writes
        it out as a PEG\. The result is nicely formatted and partially simplified
        \(strings as sequences of characters\)\. A pretty printer in essence, but
        can also be used to obtain a canonical representation of the input
        grammar\.

      * *tpc*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar and writes
        out Tcl code defining a package which defines a
        __[grammar::peg](\.\./modules/grammar\_peg/peg\.md)__ object
        containing the grammar when it is loaded into an interpreter\.

      * *hb*

        This is like the writer plugin *tpc*, but it writes only the
        statements which define stat expression and grammar rules\. The code
        making the result a package is left out\.

      * *ser*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar, transforms
        it internally into a
        __[grammar::peg](\.\./modules/grammar\_peg/peg\.md)__ object and
        writes out its serialization\.

      * *me*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar and writes
        out Tcl code defining a package which implements a memoizing recursive
        descent parser based on the match engine \(ME\) provided by the package
        __grammar::mengine__\.

  - __\-t__ *name*

    Transformers\. The name of the package for the plugin *name* is
    "page::transform::*name*"\.

    We have two predefined plugins:

      * *reach*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar\. It
        determines which nonterminal symbols and rules are reachable from
        start\-symbol/expression\. All nonterminal symbols which were not reached
        are removed\.

      * *use*

        Assumes that the incoming data structure is a tree representation of a
        *[PEG](\.\./\.\./\.\./index\.md\#peg)* or other other grammar\. It
        determines which nonterminal symbols and rules are able to generate a
        *finite* sequences of terminal symbols \(in the sense for a Context
        Free Grammar\)\. All nonterminal symbols which were not deemed useful in
        this sense are removed\.

## <a name='subsection5'></a>PLUGIN LOCATIONS

The application\-specific paths searched by __page__ either are, or come
from:

  1. The directory "~/\.page/plugin"

  1. The environment variable *PAGE\_PLUGINS*

  1. The registry entry *HKEY\_LOCAL\_MACHINE\\SOFTWARE\\PAGE\\PLUGINS*

  1. The registry entry *HKEY\_CURRENT\_USER\\SOFTWARE\\PAGE\\PLUGINS*

The type\-specific paths searched by __page__ either are, or come from:

  1. The directory "~/\.page/plugin/<TYPE>"

  1. The environment variable *PAGE\_<TYPE>\_PLUGINS*

  1. The registry entry *HKEY\_LOCAL\_MACHINE\\SOFTWARE\\PAGE\\<TYPE>\\PLUGINS*

  1. The registry entry *HKEY\_CURRENT\_USER\\SOFTWARE\\PAGE\\<TYPE>\\PLUGINS*

Where the placeholder *<TYPE>* is always one of the values below, properly
capitalized\.

  1. reader

  1. writer

  1. transform

  1. config

The registry entries are specific to the Windows\(tm\) platform, all other
platforms will ignore them\.

The contents of both environment variables and registry entries are interpreted
as a list of paths, with the elements separated by either colon \(Unix\), or
semicolon \(Windows\)\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *page* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

page::pluginmgr

# <a name='keywords'></a>KEYWORDS

[parser generator](\.\./\.\./\.\./index\.md\#parser\_generator), [text
processing](\.\./\.\./\.\./index\.md\#text\_processing)

# <a name='category'></a>CATEGORY

Page Parser Generator

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/apps/pt.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799

[//000000001]: # (pt \- Parser Tools)
[//000000002]: # (Generated from file 'pt\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2009 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (pt\(n\) 1 tcllib "Parser Tools")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

pt \- Parser Tools Application

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [Command Line](#section2)

  - [PEG Specification Language](#section3)

  - [JSON Grammar Exchange](#section4)

  - [C Parser Embedded In Tcl](#section5)

  - [C Parser](#section6)

  - [Snit Parser](#section7)

  - [TclOO Parser](#section8)

  - [Grammar Container](#section9)

  - [Example](#section10)

  - [Internals](#section11)

  - [Bugs, Ideas, Feedback](#section12)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.5  

[__pt__ __generate__ *resultformat* ?*options\.\.\.*? *resultfile* *inputformat* *inputfile*](#1)  

# <a name='description'></a>DESCRIPTION

Are you lost ? Do you have trouble understanding this document ? In that case
please read the overview provided by the *[Introduction to Parser
Tools](\.\./modules/pt/pt\_introduction\.md)*\. This document is the entrypoint
to the whole system the current package is a part of\.

This document describes __pt__, the main application of the module, a
*[parser generator](\.\./\.\./\.\./index\.md\#parser\_generator)*\. Its intended
audience are people who wish to create a parser for some language of theirs\.
Should you wish to modify the application instead, please see the section about
the application's [Internals](#section11) for the basic references\.

It resides in the User Application Layer of Parser Tools\.

![](\.\./\.\./\.\./image/arch\_user\_app\.png)

# <a name='section2'></a>Command Line

  - <a name='1'></a>__pt__ __generate__ *resultformat* ?*options\.\.\.*? *resultfile* *inputformat* *inputfile*

    This sub\-command of the application reads the parsing expression grammar
    stored in the *inputfile* in the format *inputformat*, converts it to
    the *resultformat* under the direction of the \(format\-specific\) set of
    options specified by the user and stores the result in the *resultfile*\.

    The *inputfile* has to exist, while the *resultfile* may be created,
    overwriting any pre\-existing content of the file\. Any missing directory in
    the path to the *resultfile* will be created as well\.

    The exact form of the result for, and the set of options supported by the
    known result\-formats, are explained in the upcoming sections of this
    document, with the list below providing an index mapping between format name
    and its associated section\. In alphabetical order:

      * __c__

        A *resultformat*\. See section [C Parser](#section6)\.

      * __container__

        A *resultformat*\. See section [Grammar Container](#section9)\.

      * __critcl__

        A *resultformat*\. See section [C Parser Embedded In
        Tcl](#section5)\.

      * __json__

        A *input*\- and *resultformat*\. See section [JSON Grammar
        Exchange](#section4)\.

      * __oo__

        A *resultformat*\. See section [TclOO Parser](#section8)\.

      * __peg__

        A *input*\- and *resultformat*\. See section [PEG Specification
        Language](#section3)\.

      * __snit__

        A *resultformat*\. See section [Snit Parser](#section7)\.

Of the seven possible results four are parsers outright \(__c__,
__critcl__, __oo__, and __snit__\), one \(__container__\) provides
code which can be used in conjunction with a generic parser \(also known as a
grammar interpreter\), and the last two \(__json__ and __peg__\) are doing
double\-duty as input formats, allowing the transformation of grammars for
exchange, reformatting, and the like\.

The created parsers fall into three categories:

![](\.\./\.\./\.\./image/gen\_options\.png)

  - __Specialized parsers implemented in C__

    The fastest parsers are created when using the result formats __c__ and
    __critcl__\. The first returns the raw C code for the parser, while the
    latter wraps it into a Tcl package using *CriTcl*\.

    This makes the latter much easier to use than the former\. On the other hand,
    the former can be adapted to the users' requirements through a multitude of
    options, allowing for things like usage of the parser outside of a Tcl
    environment, something the __critcl__ format doesn't support\. As such
    the __c__ format is meant for more advanced users, or users with special
    needs\.

    A disadvantage of all the parsers in this section is the need to run them
    through a C compiler to make them actually executable\. This is not something
    everyone has the necessary tools for\. The parsers in the next section are
    for people under such restrictions\.

  - __Specialized parsers implemented in Tcl__

    As the parsers in this section are implemented in Tcl they are quite a bit
    slower than anything from the previous section\. On the other hand this
    allows them to be used in pure\-Tcl environments, or in environments which
    allow only a limited set of binary packages\. In the latter case it will be
    advantageous to lobby for the inclusion of the C\-based runtime support
    \(notes below\) into the environment to reduce the impact of Tcl's on the
    speed of these parsers\.

    The relevant formats are __snit__ and __oo__\. Both place their
    result into a Tcl package containing a __snit::type__, or TclOO
    __[class](\.\./\.\./\.\./index\.md\#class)__ respectively\.

    Of the supporting runtime, which is the package
    __[pt::rde](\.\./modules/pt/pt\_rdengine\.md)__, the user has to know
    nothing but that it does exist and that the parsers are dependent on it\.
    Knowledge of the API exported by the runtime for the parsers' consumption is
    *not* required by the parsers' users\.

  - __Interpreted parsing implemented in Tcl__

    The last category, grammar interpretation\. This means that an interpreter
    for parsing expression grammars takes the description of the grammar to
    parse input for, and uses it guide the parsing process\. This is the slowest
    of the available options, as the interpreter has to continually run through
    the configured grammar, whereas the specialized parsers of the previous
    sections have the relevant knowledge about the grammar baked into them\.

    The only places where using interpretation make sense is where the grammar
    for some input may be changed interactively by the user, as the
    interpretation allows for quick turnaround after each change, whereas the
    previous methods require the generation of a whole new parser, which is not
    as fast\. On the other hand, wherever the grammar to use is fixed, the
    previous methods are much more advantageous as the time to generate the
    parser is minuscule compared to the time the parser code is in use\.

    The relevant result format is __container__\. It \(quickly\) generates
    grammar descriptions \(instead of a full parser\) which match the API expected
    by ParserTools' grammar interpreter\. The latter is provided by the package
    __[pt::peg::interp](\.\./modules/pt/pt\_peg\_interp\.md)__\.

All the parsers generated by __critcl__, __snit__, and __oo__, and
the grammar interpreter share a common API for access to the actual parsing
functionality, making them all plug\-compatible\. It is described in the
*[Parser API](\.\./modules/pt/pt\_parser\_api\.md)* specification document\.

# <a name='section3'></a>PEG Specification Language

__peg__, a language for the specification of parsing expression grammars is
meant to be human readable, and writable as well, yet strict enough to allow its
processing by machine\. Like any computer language\. It was defined to make
writing the specification of a grammar easy, something the other formats found
in the Parser Tools do not lend themselves too\.

For either an introduction to or the formal specification of the language,
please go and read the *[PEG Language
Tutorial](\.\./modules/pt/pt\_peg\_language\.md)*\.

When used as a result\-format this format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-template__ string

    The value of this option is a string into which to put the generated text
    and the values of the other options\. The various locations for user\-data are
    expected to be specified with the placeholders listed below\. The default
    value is "__@code@__"\.

      * __@user@__

        To be replaced with the value of the option __\-user__\.

      * __@format@__

        To be replaced with the the constant __PEG__\.

      * __@file@__

        To be replaced with the value of the option __\-file__\.

      * __@name@__

        To be replaced with the value of the option __\-name__\.

      * __@code@__

        To be replaced with the generated text\.

# <a name='section4'></a>JSON Grammar Exchange

The __json__ format for parsing expression grammars was written as a data
exchange format not bound to Tcl\. It was defined to allow the exchange of
grammars with PackRat/PEG based parser generators for other languages\.

For the formal specification of the JSON grammar exchange format, please go and
read *[The JSON Grammar Exchange
Format](\.\./modules/pt/pt\_json\_language\.md)*\.

When used as a result\-format this format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-indented__ boolean

    If this option is set the system will break the generated JSON across lines
    and indent it according to its inner structure, with each key of a
    dictionary on a separate line\.

    If the option is not set \(the default\), the whole JSON object will be
    written on a single line, with minimum spacing between all elements\.

  - __\-aligned__ boolean

    If this option is set the system will ensure that the values for the keys in
    a dictionary are vertically aligned with each other, for a nice table
    effect\. To make this work this also implies that __\-indented__ is set\.

    If the option is not set \(the default\), the output is formatted as per the
    value of __indented__, without trying to align the values for dictionary
    keys\.

# <a name='section5'></a>C Parser Embedded In Tcl

The __critcl__ format is executable code, a parser for the grammar\. It is a
Tcl package with the actual parser implementation written in C and embedded in
Tcl via the __critcl__ package\.

This result\-format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-class__ string

    The value of this option is the name of the class to generate, without
    leading colons\. The default value is __CLASS__\.

    For a simple value __X__ without colons, like CLASS, the parser command
    will be __X__::__X__\. Whereas for a namespaced value __X::Y__
    the parser command will be __X::Y__\.

  - __\-package__ string

    The value of this option is the name of the package to generate\. The default
    value is __PACKAGE__\.

  - __\-version__ string

    The value of this option is the version of the package to generate\. The
    default value is __1__\.

# <a name='section6'></a>C Parser

The __c__ format is executable code, a parser for the grammar\. The parser
implementation is written in C and can be tweaked to the users' needs through a
multitude of options\.

The __critcl__ format, for example, is implemented as a canned configuration
of these options on top of the generator for __c__\.

This result\-format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-template__ string

    The value of this option is a string into which to put the generated text
    and the other configuration settings\. The various locations for user\-data
    are expected to be specified with the placeholders listed below\. The default
    value is "__@code@__"\.

      * __@user@__

        To be replaced with the value of the option __\-user__\.

      * __@format@__

        To be replaced with the the constant __C/PARAM__\.

      * __@file@__

        To be replaced with the value of the option __\-file__\.

      * __@name@__

        To be replaced with the value of the option __\-name__\.

      * __@code@__

        To be replaced with the generated Tcl code\.

    The following options are special, in that they will occur within the
    generated code, and are replaced there as well\.

      * __@statedecl@__

        To be replaced with the value of the option __state\-decl__\.

      * __@stateref@__

        To be replaced with the value of the option __state\-ref__\.

      * __@strings@__

        To be replaced with the value of the option __string\-varname__\.

      * __@self@__

        To be replaced with the value of the option __self\-command__\.

      * __@def@__

        To be replaced with the value of the option __fun\-qualifier__\.

      * __@ns@__

        To be replaced with the value of the option __namespace__\.

      * __@main@__

        To be replaced with the value of the option __main__\.

      * __@prelude@__

        To be replaced with the value of the option __prelude__\.

  - __\-state\-decl__ string

    A C string representing the argument declaration to use in the generated
    parsing functions to refer to the parsing state\. In essence type and
    argument name\. The default value is the string __RDE\_PARAM p__\.

  - __\-state\-ref__ string

    A C string representing the argument named used in the generated parsing
    functions to refer to the parsing state\. The default value is the string
    __p__\.

  - __\-self\-command__ string

    A C string representing the reference needed to call the generated parser
    function \(methods \.\.\.\) from another parser fonction, per the chosen
    framework \(template\)\. The default value is the empty string\.

  - __\-fun\-qualifier__ string

    A C string containing the attributes to give to the generated functions
    \(methods \.\.\.\), per the chosen framework \(template\)\. The default value is
    __static__\.

  - __\-namespace__ string

    The name of the C namespace the parser functions \(methods, \.\.\.\) shall reside
    in, or a general prefix to add to the function names\. The default value is
    the empty string\.

  - __\-main__ string

    The name of the main function \(method, \.\.\.\) to be called by the chosen
    framework \(template\) to start parsing input\. The default value is
    __\_\_main__\.

  - __\-string\-varname__ string

    The name of the variable used for the table of strings used by the generated
    parser, i\.e\. error messages, symbol names, etc\. The default value is
    __p\_string__\.

  - __\-prelude__ string

    A snippet of code to be inserted at the head of each generated parsing
    function\. The default value is the empty string\.

  - __\-indent__ integer

    The number of characters to indent each line of the generated code by\. The
    default value is __0__\.

  - __\-comments__ boolean

    A flag controlling the generation of code comments containing the original
    parsing expression a parsing function is for\. The default value is
    __on__\.

# <a name='section7'></a>Snit Parser

The __snit__ format is executable code, a parser for the grammar\. It is a
Tcl package holding a __snit::type__, i\.e\. a class, whose instances are
parsers for the input grammar\.

This result\-format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-class__ string

    The value of this option is the name of the class to generate, without
    leading colons\. Note, it serves double\-duty as the name of the package to
    generate too, if option __\-package__ is not specified, see below\. The
    default value is __CLASS__, applying if neither option __\-class__
    nor __\-package__ were specified\.

  - __\-package__ string

    The value of this option is the name of the package to generate, without
    leading colons\. Note, it serves double\-duty as the name of the class to
    generate too, if option __\-class__ is not specified, see above\. The
    default value is __PACKAGE__, applying if neither option
    __\-package__ nor __\-class__ were specified\.

  - __\-version__ string

    The value of this option is the version of the package to generate\. The
    default value is __1__\.

# <a name='section8'></a>TclOO Parser

The __oo__ format is executable code, a parser for the grammar\. It is a Tcl
package holding a __[TclOO](\.\./\.\./\.\./index\.md\#tcloo)__ class, whose
instances are parsers for the input grammar\.

This result\-format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-class__ string

    The value of this option is the name of the class to generate, without
    leading colons\. Note, it serves double\-duty as the name of the package to
    generate too, if option __\-package__ is not specified, see below\. The
    default value is __CLASS__, applying if neither option __\-class__
    nor __\-package__ were specified\.

  - __\-package__ string

    The value of this option is the name of the package to generate, without
    leading colons\. Note, it serves double\-duty as the name of the class to
    generate too, if option __\-class__ is not specified, see above\. The
    default value is __PACKAGE__, applying if neither option
    __\-package__ nor __\-class__ were specified\.

  - __\-version__ string

    The value of this option is the version of the package to generate\. The
    default value is __1__\.

# <a name='section9'></a>Grammar Container

The __container__ format is another form of describing parsing expression
grammars\. While data in this format is executable it does not constitute a
parser for the grammar\. It always has to be used in conjunction with the package
__[pt::peg::interp](\.\./modules/pt/pt\_peg\_interp\.md)__, a grammar
interpreter\.

The format represents grammars by a __snit::type__, i\.e\. class, whose
instances are API\-compatible to the instances of the
__[pt::peg::container](\.\./modules/pt/pt\_peg\_container\.md)__ package, and
which are preloaded with the grammar in question\.

This result\-format supports the following options:

  - __\-file__ string

    The value of this option is the name of the file or other entity from which
    the grammar came, for which the command is run\. The default value is
    __unknown__\.

  - __\-name__ string

    The value of this option is the name of the grammar we are processing\. The
    default value is __a\_pe\_grammar__\.

  - __\-user__ string

    The value of this option is the name of the user for which the command is
    run\. The default value is __unknown__\.

  - __\-mode__ __bulk__&#124;__incremental__

    The value of this option controls which methods of
    __[pt::peg::container](\.\./modules/pt/pt\_peg\_container\.md)__
    instances are used to specify the grammar, i\.e\. preload it into the
    container\. There are two legal values, as listed below\. The default is
    __bulk__\.

      * __bulk__

        In this mode the methods __start__, __add__, __modes__, and
        __rules__ are used to specify the grammar in a bulk manner, i\.e\. as
        a set of nonterminal symbols, and two dictionaries mapping from the
        symbols to their semantic modes and parsing expressions\.

        This mode is the default\.

      * __incremental__

        In this mode the methods __start__, __add__, __mode__, and
        __rule__ are used to specify the grammar piecemal, with each
        nonterminal having its own block of defining commands\.

  - __\-template__ string

    The value of this option is a string into which to put the generated code
    and the other configuration settings\. The various locations for user\-data
    are expected to be specified with the placeholders listed below\. The default
    value is "__@code@__"\.

      * __@user@__

        To be replaced with the value of the option __\-user__\.

      * __@format@__

        To be replaced with the the constant __CONTAINER__\.

      * __@file@__

        To be replaced with the value of the option __\-file__\.

      * __@name@__

        To be replaced with the value of the option __\-name__\.

      * __@mode@__

        To be replaced with the value of the option __\-mode__\.

      * __@code@__

        To be replaced with the generated code\.

# <a name='section10'></a>Example

In this section we are working a complete example, starting with a PEG grammar
and ending with running the parser generated from it over some input, following
the outline shown in the figure below:

![](\.\./\.\./\.\./image/flow\.png) Our grammar, assumed to the stored in the file
"calculator\.peg" is

    PEG calculator (Expression)
        Digit      <- '0'/'1'/'2'/'3'/'4'/'5'/'6'/'7'/'8'/'9'       ;
        Sign       <- '-' / '+'                                     ;
        Number     <- Sign? Digit+                                  ;
        Expression <- Term (AddOp Term)*                            ;
        MulOp      <- '*' / '/'                                     ;
        Term       <- Factor (MulOp Factor)*                        ;
        AddOp      <- '+'/'-'                                       ;
        Factor     <- '(' Expression ')' / Number                   ;
    END;

From this we create a snit\-based parser via

    pt generate snit calculator.tcl -class calculator -name calculator peg calculator.peg

which leaves us with the parser package and class written to the file
"calculator\.tcl"\. Assuming that this package is then properly installed in a
place where Tcl can find it we can now use this class via a script like

    package require calculator

    lassign $argv input
    set channel [open $input r]

    set parser [calculator]
    set ast [$parser parse $channel]
    $parser destroy
    close $channel

    ... now process the returned abstract syntax tree ...

where the abstract syntax tree stored in the variable will look like

    set ast {Expression 0 4
        {Factor 0 4
            {Term 0 2
                {Number 0 2
                    {Digit 0 0}
                    {Digit 1 1}
                    {Digit 2 2}
                }
            }
            {AddOp 3 3}
            {Term 4 4
                {Number 4 4
                    {Digit 4 4}
                }
            }
        }
    }

assuming that the input file and channel contained the text

    120+5

A more graphical representation of the tree would be

![](\.\./\.\./\.\./image/expr\_ast\.png) Regardless, at this point it is the user's
responsibility to work with the tree to reach whatever goal she desires\. I\.e\.
analyze it, transform it, etc\. The package
__[pt::ast](\.\./modules/pt/pt\_astree\.md)__ should be of help here,
providing commands to walk such ASTs structures in various ways\.

One important thing to note is that the parsers used here return a data
structure representing the structure of the input per the grammar underlying the
parser\. There are *no* callbacks during the parsing process, i\.e\. no *parsing
actions*, as most other parsers will have\.

Going back to the last snippet of code, the execution of the parser for some
input, note how the parser instance follows the specified *[Parser
API](\.\./modules/pt/pt\_parser\_api\.md)*\.

# <a name='section11'></a>Internals

This section is intended for users of the application which wish to modify or
extend it\. Users only interested in the generation of parsers can ignore it\.

The main functionality of the application is encapsulated in the package
__[pt::pgen](\.\./modules/pt/pt\_pgen\.md)__\. Please read it for more
information\.

# <a name='section12'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *pt* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[EBNF](\.\./\.\./\.\./index\.md\#ebnf), [LL\(k\)](\.\./\.\./\.\./index\.md\#ll\_k\_),
[PEG](\.\./\.\./\.\./index\.md\#peg), [TDPL](\.\./\.\./\.\./index\.md\#tdpl),
[context\-free languages](\.\./\.\./\.\./index\.md\#context\_free\_languages),
[expression](\.\./\.\./\.\./index\.md\#expression),
[grammar](\.\./\.\./\.\./index\.md\#grammar),
[matching](\.\./\.\./\.\./index\.md\#matching),
[parser](\.\./\.\./\.\./index\.md\#parser), [parsing
expression](\.\./\.\./\.\./index\.md\#parsing\_expression), [parsing expression
grammar](\.\./\.\./\.\./index\.md\#parsing\_expression\_grammar), [push down
automaton](\.\./\.\./\.\./index\.md\#push\_down\_automaton), [recursive
descent](\.\./\.\./\.\./index\.md\#recursive\_descent),
[state](\.\./\.\./\.\./index\.md\#state), [top\-down parsing
languages](\.\./\.\./\.\./index\.md\#top\_down\_parsing\_languages),
[transducer](\.\./\.\./\.\./index\.md\#transducer)

# <a name='category'></a>CATEGORY

Parsing and Grammars

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2009 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






























































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/apps/tcldocstrip.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221

[//000000001]: # (tcldocstrip \- Textprocessing toolbox)
[//000000002]: # (Generated from file 'tcldocstrip\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (tcldocstrip\(n\) 1\.0 tcllib "Textprocessing toolbox")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcldocstrip \- Tcl\-based Docstrip Processor

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

      - [USE CASES](#subsection1)

      - [COMMAND LINE](#subsection2)

      - [OPTIONS](#subsection3)

  - [Bugs, Ideas, Feedback](#section2)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

[__tcldocstrip__ *output* ?options? *input* ?*guards*?](#1)  
[__tcldocstrip__ ?options? *output* \(?options? *input* *guards*\)\.\.\.](#2)  
[__tcldocstrip__ __\-guards__ *input*](#3)  

# <a name='description'></a>DESCRIPTION

The application described by this document, __tcldocstrip__, is a relative
of __[docstrip](\.\./modules/docstrip/docstrip\.md)__, a simple literate
programming tool for LaTeX\.

__tcldocstrip__ is based upon the package
__[docstrip](\.\./modules/docstrip/docstrip\.md)__\.

## <a name='subsection1'></a>USE CASES

__tcldocstrip__ was written with the following three use cases in mind\.

  1. Conversion of a single input file according to the listed guards into the
     stripped output\. This handles the most simple case of a set of guards
     specifying a single document found in a single input file\.

  1. Stitching, or the assembly of an output from several sets of guards, in a
     specific order, and possibly from different files\. This is the second
     common case\. One document spread over several inputs, and/or spread over
     different guard sets\.

  1. Extraction and listing of all the unique guard expressions and guards used
     within a document to help a person which did not author the document in
     question in familiarizing itself with it\.

## <a name='subsection2'></a>COMMAND LINE

  - <a name='1'></a>__tcldocstrip__ *output* ?options? *input* ?*guards*?

    This is the form for use case \[1\]\. It converts the *input* file according
    to the specified *guards* and options\. The result is written to the named
    *output* file\. Usage of the string __\-__ as the name of the output
    signals that the result should be written to __stdout__\. The guards are
    document\-specific and have to be known to the caller\. The *options* will
    be explained later, in section [OPTIONS](#subsection3)\.

      * path *output* \(in\)

        This argument specifies where to write the generated document\. It can be
        the path to a file or directory, or __\-__\. The last value causes the
        application to write the generated documented to __stdout__\.

        If the *output* does not exist then \[file dirname $output\] has to
        exist and must be a writable directory\.

      * path *inputfile* \(in\)

        This argument specifies the path to the file to process\. It has to
        exist, must be readable, and written in
        *[docstrip](\.\./\.\./\.\./index\.md\#docstrip)* format\.

  - <a name='2'></a>__tcldocstrip__ ?options? *output* \(?options? *input* *guards*\)\.\.\.

    This is the form for use case \[2\]\. It differs from the form for use case \[1\]
    by the possibility of having options before the output file, which apply in
    general, and specifying more than one inputfile, each with its own set of
    input specific options and guards\.

    It extracts data from the various *input* files, according to the
    specified *options* and *guards*, and writes the result to the given
    *output*, in the order of their specification on the command line\. Options
    specified before the output are global settings, whereas the options
    specified before each input are valid only just for this input file\.
    Unspecified values are taken from the global settings, or defaults\. As for
    form \[1\] using the string __\-__ as output causes the application to
    write to stdout\. Using the string __\.__ for an input file signals that
    the last input file should be used again\. This enables the assembly of the
    output from one input file using multiple and different sets of guards,
    without having to specify the full name of the file every time\.

  - <a name='3'></a>__tcldocstrip__ __\-guards__ *input*

    This is the form for use case \[3\]\. It determines the guards, and unique
    guard expressions used within the provided *input* document\. The found
    strings are written to stdout, one string per line\.

## <a name='subsection3'></a>OPTIONS

This section describes all the options available to the user of the application,
with the exception of the option __\-guards__\. This option was described
already, in section [COMMAND LINE](#subsection2)\.

  - __\-metaprefix__ string

    This option is inherited from the command __docstrip::extract__ provided
    by the package __[docstrip](\.\./modules/docstrip/docstrip\.md)__\.

    It specifies the string by which the '%%' prefix of a metacomment line will
    be replaced\. Defaults to '%%'\. For Tcl code this would typically be '\#'\.

  - __\-onerror__ mode

    This option is inherited from the command __docstrip::extract__ provided
    by the package __[docstrip](\.\./modules/docstrip/docstrip\.md)__\.

    It controls what will be done when a format error in the *text* being
    processed is detected\. The settings are:

      * __ignore__

        Just ignore the error; continue as if nothing happened\.

      * __puts__

        Write an error message to __stderr__, then continue processing\.

      * __throw__

        Throw an error\. __::errorCode__ is set to a list whose first element
        is __DOCSTRIP__, second element is the type of error, and third
        element is the line number where the error is detected\. This is the
        default\.

  - __\-trimlines__ bool

    This option is inherited from the command __docstrip::extract__ provided
    by the package __[docstrip](\.\./modules/docstrip/docstrip\.md)__\.

    Controls whether *spaces* at the end of a line should be trimmed away
    before the line is processed\. Defaults to __true__\.

  - __\-preamble__ text

  - __\-postamble__ text

  - __\-nopreamble__

  - __\-nopostamble__

    The \-no\*amble options deactivate file pre\- and postambles altogether,
    whereas the \-\*amble options specify the *user* part of the file pre\- and
    postambles\. This part can be empty, in that case only the standard parts are
    shown\. This is the default\.

    Preambles, when active, are written before the actual content of a generated
    file\. In the same manner postambles are, when active, written after the
    actual content of a generated file\.

# <a name='section2'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *docstrip* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[docstrip](\.\./modules/docstrip/docstrip\.md)

# <a name='keywords'></a>KEYWORDS

[\.dtx](\.\./\.\./\.\./index\.md\#\_dtx), [LaTeX](\.\./\.\./\.\./index\.md\#latex),
[conversion](\.\./\.\./\.\./index\.md\#conversion),
[docstrip](\.\./\.\./\.\./index\.md\#docstrip),
[documentation](\.\./\.\./\.\./index\.md\#documentation), [literate
programming](\.\./\.\./\.\./index\.md\#literate\_programming),
[markup](\.\./\.\./\.\./index\.md\#markup), [source](\.\./\.\./\.\./index\.md\#source)

# <a name='category'></a>CATEGORY

Documentation tools

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2005 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/devdoc/tcl_community_communication.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

[//000000001]: # (tcl\_community\_communication \- )
[//000000002]: # (Generated from file 'tcl\_community\_communication\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcl\_community\_communication\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcl\_community\_communication \- Tcl Community \- Kind Communication

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [Signatories](#section2)

  - [Authors](#section3)

# <a name='description'></a>DESCRIPTION

The Tcl Community encourages contributions from anyone who wishes to advance the
development of:

  - The Tcl Language

  - Tcl derived languages

  - Tcl related libraries

  - Tcl extensions

  - External Projects that Integrate Tcl

We welcome those contributions from anyone\. We are blind to gender, race,
religion, cultural background, cybernetic nature, and any other demographic
characteristics, as well as personal political views\.

A community lives and dies by communications\. And occasionally our
communications are peppered with patterns that are harsh, unfriendly,
unwelcoming and/or otherwise unkind\. As a volunteer community, we need all of
the help we can get\. Therefore, we ask all contributors to make a conscious
effort, in Tcl Community discussions, to communicate in ways that are welcoming\.
Ways that are friendly\. Ways that are, in a word: kind\.

These guidelines suggest specific ways to accomplish that goal\.

Please note: for the balance of this document any reference to "People",
"Persons", "anybody" or "somebody" can refer to any sentient being, not merely
corporeal members of the species Homo Sapien\.

  - We are a Sanctuary not a Clubhouse

    The Tcl Community is a collective of amateurs and professionals who code,
    test, and use tools\. Our community is open to all\. There is no velvet rope\.
    There is no bouncer at the door\. There are no secret handshakes\. Any
    sentient being who enters our midst is welcome\. If someone is ever asked to
    leave, it is only because they are being disruptive to the functioning of
    the community\.

  - We Merit Ideas, Not People

    A good idea can come from anyone, regardless of how little time they have
    been with us\. A bad idea can come from anyone, regardless of how much time
    or how little time they have been with us\. We judge a concept by how it
    stands up to scrutiny of logic, implementation, and regression testing\. We
    don’t judge ideas based on who had the idea first, who agrees with the idea,
    or who disagrees with it\.

  - Treat Everyone with Respect

    Everyone is deserving of respect and courtesy at all times\.

  - Refer to people by the names they use\.

    If grammar requires you to state a gender for a person, honor their
    preferences about their gender identity\. If you are unsure as to the gender
    of an individual, ask\. If someone had to guess about your gender and got it
    wrong, please correct them and do not take it personally\.

  - Do not take a harsh tone towards other participants\.

    Do not make personal attacks against anyone \(participant or not\.\)

    Criticize statements and actions, never people\.

  - Don’t Take Things Personally

    When in doubt, assume the best in people\. A criticism of your statements is
    not a personal attack on you\.

  - Persons, not People

    Stereotypes are an unhelpful tool on many accounts\. They are generally
    oversimplified\. They are usually flat out wrong\. And even if "right" they
    are of absolutely no utility in determining the capabilities, motivations,
    or fitness of an individual\.

    Don’t use them in Tcl Community communications\.

  - Mistakes Happen

    The human condition is a series of trials and errors\. Progress is when we
    get one more trial than error\. Being wrong or making a mistake is the
    default state of humanity\. Accept the errors of your fellow sentient beings,
    and be aware that you are also fallible\.

  - Keep it Real

    Please respond to what people actually say\. We are all amazing individuals,
    but none among us are mind readers\. If you find yourself responding to what
    you imagine someone is thinking, odds are you are going to be wrong\.

    If you must criticize someone, stick to things they have actually done\.
    Never criticize for something you speculate they have done\. Or imagine they
    have done\. Or something someone who shares some attribute with them has done
    in the past\.

    Keep discussions about any non\-Tcl subjects to what can be stated factually
    and without emotion or judgement\.

  - When Trouble Arises, Don’t Escalate

    If you feel you are being personally attacked or offended, take the high
    road\. Punching back in a public forum will only makes things worse\. Address
    the matter in a private correspondence\. Be polite\. Express your feelings,
    but note that you are expressing your feelings\. When writing, look for a way
    to calm matters down\. And when in doubt, sleep on your letter before
    pressing send\. And when not in doubt, sleep on it for another day after
    that\.

    If you are a spectator to a fight in progress, politely request the two
    parties take the matter to a more private forum\.

  - Always get the Last Word: I’m Sorry

    If an personal argument does arise, be the first to apologize\. An apology
    does not concede a logical point\. It merely acknowledges that at some point
    the discussion left either logic, community decency, or both\. Return to the
    topic when cooler heads can prevail\.

  - Nobody is Keeping Score

    There is no prize for being right\. There is no cost for being wrong\. A hard
    sell is not going to advance your idea along any more than a logical
    argument\. You aren’t running for office\. This isn’t debate club\. If you find
    yourself continuing a discussion beyond where a topic can be logically
    discussed, stop\.

  - No Evangelizing

    The Tcl Community is not the place to promote your chosen operating system,
    political outlook, religion, marketing scheme, or economic model\. Period\.

    \(And if you do bring it up, be prepared to have your chosen topic discussed
    logically\. And odds are, not favorably\.\)

  - Respect the Community

    If the Community has come to a decision on a course of action, please stop
    arguing\.

    If someone complains about how you are expressing your ideas, listen\.

    If your words are hurting people, stop\. There is no amount of being "right"
    that makes up for someone leaving our midst because they felt insulted,
    threatened, or ignored\.

By following these guidelines, we will build our community, encourage more
contribution to our projects, and our discussions will be friendlier and reach
conclusions more easily\.

Thank You\.

# <a name='section2'></a>Signatories

  - Sean "the Hypnotoad" Woods

  - Andreas Kupries

# <a name='section3'></a>Authors

  - Primary

    Sean "the Hypnotoad" Woods

  - Light editing

    Andreas Kupries
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<








































































































































































































































































































































































































Deleted embedded/md/tcllib/files/devdoc/tcllib_devguide.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046

[//000000001]: # (tcllib\_devguide \- )
[//000000002]: # (Generated from file 'tcllib\_devguide\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcllib\_devguide\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcllib\_devguide \- Tcllib \- The Developer's Guide

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [Commitments](#section2)

      - [Contributor](#subsection1)

      - [Maintainer](#subsection2)

  - [Branching and Workflow](#section3)

      - [Package Dependencies](#subsection3)

      - [Trunk](#subsection4)

      - [Branches](#subsection5)

      - [Working with Branches](#subsection6)

      - [Version numbers](#subsection7)

  - [Structural Overview](#section4)

      - [Main Directories](#subsection8)

      - [More Directories](#subsection9)

      - [Top Files](#subsection10)

      - [File Types](#subsection11)

  - [Testsuite Tooling](#section5)

      - [Invoke the testsuites of a specific module](#subsection12)

      - [Invoke the testsuites of all modules](#subsection13)

      - [Detailed Test Logs](#subsection14)

      - [Shell Selection](#subsection15)

      - [Help](#subsection16)

  - [Documentation Tooling](#section6)

      - [Generate documentation for a specific module](#subsection17)

      - [Generate documentation for all modules](#subsection18)

      - [Available output formats, help](#subsection19)

      - [Validation without output](#subsection20)

  - [Notes On Writing A Testsuite](#section7)

  - [Installation Tooling](#section8)

# <a name='synopsis'></a>SYNOPSIS

[__[Module](\.\./\.\./\.\./index\.md\#module)__ *name* *code\-action* *doc\-action* *example\-action*](#1)  
[__[Application](\.\./\.\./\.\./index\.md\#application)__ *name*](#2)  
[__Exclude__ *name*](#3)  

# <a name='description'></a>DESCRIPTION

Welcome to Tcllib, the Tcl Standard Library\. Note that Tcllib is not a package
itself\. It is a collection of \(semi\-independent\)
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* packages that provide utility functions
useful to a large collection of Tcl programmers\.

This document is a guide for developers working on Tcllib, i\.e\. maintainers
fixing bugs, extending the collection's functionality, etc\.

Please read

  1. *[Tcllib \- How To Get The Sources](tcllib\_sources\.md)* and

  1. *[Tcllib \- The Installer's Guide](tcllib\_installer\.md)*

first, if that was not done already\.

Here we assume that the sources are already available in a directory of your
choice, and that you not only know how to build and install them, but also have
all the necessary requisites to actually do so\. The guide to the sources in
particular also explains which source code management system is used, where to
find it, how to set it up, etc\.

# <a name='section2'></a>Commitments

## <a name='subsection1'></a>Contributor

As a contributor to Tcllib you are committing yourself to:

  1. keep the guidelines written down in *[Tcl Community \- Kind
     Communication](tcl\_community\_communication\.md)* in your mind\. The main
     point to take away from there is *to be kind to each other*\.

  1. Your contributions getting distributed under a BSD/MIT license\. For the
     details see *[Tcllib \- License](tcllib\_license\.md)*

Contributions are made by entering tickets into our tracker, providing patches,
bundles or branches of code for inclusion, or posting to the Tcllib related
mailing lists\.

## <a name='subsection2'></a>Maintainer

When contributing one or more packages for full inclusion into Tcllib you are
committing yourself to

  1. Keep the guidelines written down in *[Tcl Community \- Kind
     Communication](tcl\_community\_communication\.md)* \(as any contributor\) in
     your mind\. The main point to take away from there is *to be kind to each
     other*\.

  1. Your packages getting distributed under a BSD/MIT license\. For the details
     see *[Tcllib \- License](tcllib\_license\.md)*

  1. Maintenance of the new packages for a period of two years under the
     following rules, and responsibilities:

       1) A maintainer may step down after the mandatory period as they see fit\.

       1) A maintainer may step down before the end of the mandatory period,
          under the condition that a replacement maintainer is immediately
          available and has agreed to serve the remainder of the period, plus
          their own mandatory period \(see below\)\.

       1) When stepping down without a replacement maintainer taking over the
          relevant packages have to be flagged as __unmaintained__\.

       1) When a replacement mantainer is brought in for a package it is \(kept\)
          marked as __maintained__ \(again\)\.

          A replacement maintainer is bound by the same rules as the original
          maintainer, except that the mandatory period of maintenance is
          shortened to one year\.

       1) For any __unmaintained__ package a contributor interested in
          becoming its maintainer can become so by flagging them as
          __maintained__ with their name and contact information, committing
          themselves to the rules of a replacement maintainer \(see previous
          point\)\.

       1) For any already __maintained__ package a contributor interested in
          becoming a co\-maintainer can become so with the agreement of the
          existing maintainer\(s\), committing themselves to the rules of a
          replacement maintainer \(see two points previous\)\.

     The responsibilities as a maintainer include:

       1) Watching Tcllib's ticket tracker for bugs, bug fixes, and feature
          requests related to the new packages\.

       1) Reviewing the aforementioned tickets, rejecting or applying them

       1) Coordination and discussion with ticket submitter during the
          development and/or application of bug fixes\.

  1. Follow the [Branching and Workflow](#section3) of this guide\.

# <a name='section3'></a>Branching and Workflow

## <a name='subsection3'></a>Package Dependencies

Regarding packages and dependencies between them Tcllib occupies a middle
position between two extremes:

  1. On one side a strongly interdependent set of packages, usually by a single
     author, for a single project\. Looking at my \(Andreas Kupries\) own work
     examples of such are [Marpa](https://core\.tcl\.tk/akupries/marpa/index),
     [CRIMP](https://core\.tcl\.tk/akupries/crimp/index),
     [Kinetcl](https://core\.tcl\.tk/akupries/kinetcl/index), etc\.

     For every change the author of the project handles all the modifications
     cascading from any incompatibilities it introduced to the system\.

  1. On the other side, the world of semi\-independent projects by many different
     authors where authors know what packages their own creations depend on, yet
     usually do not know who else depends on them\.

     The best thing an author making an \(incompatible\) change to their project
     can do is to for one announce such changes in some way, and for two use
     versioning to distinguish the code before and after the change\.

     The world is then responsible for adapting, be it by updating their own
     projects to the new version, or by sticking to the old\.

As mentioned already, Tcllib lives in the middle of that\.

While we as maintainers cannot be aware of all users of Tcllib's packages, and
thus have to rely on the mechanisms touched on in point 2 above for that, the
dependencies between the packages contained in Tcllib are a different matter\.

As we are collectively responsible for the usability of Tcllib in toto to the
outside world, it behooves us to be individually mindful even of Tcllib packages
we are not directly maintaining, when they depend on packages under our
maintainership\. This may be as simple as coordinating with the maintainers of
the affected packages\. It may also require us to choose how to adapt affected
packages which do not have maintainers, i\.e\. modify them to use our changed
package properly, or modify them to properly depend on the unchanged version of
our package\.

Note that the above is not only a chore but an opportunity as well\. Additional
insight can be had by forcing ourselves to look at our package and the planned
change\(s\) from an outside perspective, to consider the ramifications of our
actions on others in general, and on dependent packages in particular\.

## <a name='subsection4'></a>Trunk

The management and use of branches is an important part of working with a
*Distributed Version Control System* \(*DVCS*\) like
[fossil](https://www\.fossil\-scm\.org/)\.

For Tcllib the main branch of the collection is *trunk*\. In
*[git](\.\./\.\./\.\./index\.md\#git)* this branch would be called *master*, and
this is exactly the case in the [github
mirror](https://github\.com/tcltk/tcllib/) of Tcllib\.

To properly support debugging *each commit* on this branch *has to pass the
entire testsuite* of the collection\. Using bisection to determine when an issue
appeared is an example of an action made easier by this constraint\.

This is part of our collective responsibility for the usability of Tcllib in
toto to the outside world\. As *[fossil](\.\./\.\./\.\./index\.md\#fossil)* has no
mechanism to enforce this condition this is handled on the honor system for
developers and maintainers\.

To make the task easier Tcllib comes with a tool \("sak\.tcl"\) providing a number
of commands in support\. These commands are explained in the following sections
of this guide\.

While it is possible and allowed to commit directly to trunk remember the above
constraint regarding the testsuite, and the coming notes about other possible
issues with a commit\.

## <a name='subsection5'></a>Branches

Given the constraints placed on the *trunk* branch of the repository it is
\(strongly\) recommended to perform any development going beyond trivial changes
on a non\-trunk branch\.

Outside of the trunk developers are allowed to commit intermediate broken states
of their work\. Only at the end of a development cycle, when the relevant branch
is considered ready for merging, will it be necessary to perform full the set of
validations ensuring that the merge to come will create a good commit on trunk\.

Note that while a review from a second developer is not a required condition for
merging a branch it is recommended to seek out such an independent opinion as a
means of cross\-checking the work\.

It also recommended to give any new branch a name which aids in determining
additional details about it\. Examples of good things to stick into a branch name
would be

  - Developer \(nick\)name

  - Ticket hash/reference

  - One or two keywords applicable to the work

  - \.\.\.

Further, while most development branches are likely quite short\-lived, no
prohibitions exist against making longer\-lived branches\. Creators should however
be mindful that the longer such a branch exists without merges the more
divergent they will tend to be, with an associated increase in the effort which
will have to be spent on either merging from and merging to trunk\.

## <a name='subsection6'></a>Working with Branches

In the hope of engendering good work practices now a few example operations
which will come up with branches, and their associated fossil command
\(sequences\)\.

  - *Awareness*

    When developing we have to keep ourselves aware of the context of our work\.
    On what branch are we ? What files have we changed ? What new files are not
    yet known to the repository ? What has happened remotely since we used our
    checkout ? The answers to these questions become especially important when
    using a long\-lived checkout and coming back to it after some time away\.

    Commands to answer questions like the above are:

      * __fossil pull__

        Get all changes done on the remote since the last pull or sync from it\.
        This has to be done first, before any of the commands below\.

        Even if the commit in our checkout refers to the branch we want right
        now control operations committed to the remote may have changed that
        from underneath us\.

      * __fossil info &#124; grep tags__

      * __fossil branch list &#124; grep '\\\*'__

        Two different ways of determining the branch our checkout is on\.

      * __fossil timeline__

        What have we \(and others\) done recently ?

        *Attention*, this information is very likely outdated, the more the
        longer we did not use this checkout\. Run __fossil pull__ first to
        get latest information from the remote repository of the project\.

      * __fossil timeline current__

        Place the commit our checkout is based on at the top of the timeline\.

      * __fossil changes__

        Lists the files we have changed compared to the commit the checkout is
        based on\.

      * __fossil extra__

        Lists the files we have in the checkout the repository does not know
        about\. This may be leftover chaff from our work, or something we have
        forgotten to __fossil add__ to the repository yet\.

  - *Clean checkouts*

    Be aware of where you are \(see first definition\)\.

    For pretty much all the operation recipes below a clean checkout is at least
    desired, often required\. To check that a checkout is clean invoke

        fossil changes
        fossil extra

    How to clean up when uncommitted changes of all sorts are found is
    context\-specific and outside of the scope of this guide\.

  - *Starting a new branch*

    Be aware of where you are \(see first definition\)\.

    Ensure that you have clean checkout \(see second definition\)\. It is
    *required*\.

    In most situations you want to be on branch *trunk*, and you want to be on
    the latest commit for it\. To get there use

        fossil pull
        fossil update trunk

    If some other branch is desired as the starting point for the coming work
    replace *trunk* in the commands above with the name of that branch\.

    With the base line established we now have two ways of creating the new
    branch, with differing \(dis\)advantages\. The simpler way is to

        fossil branch new NAME_OF_NEW_BRANCH

    and start developing\. The advantage here is that you cannot forget to create
    the branch\. The disadvantages are that we have a branch commit unchanged
    from where we branched from, and that we have to use high\-handed techniques
    like hiding or shunning to get rid of the commit should we decide to abandon
    the work before the first actual commit on the branch\.

    The other way of creating the branch is to start developing, and then on the
    first commit use the option __\-\-branch__ to tell
    __[fossil](\.\./\.\./\.\./index\.md\#fossil)__ that we are starting a branch
    now\. I\.e\. run

        fossil commit --branch NAME_OF_NEW_BRANCH ...

    where *\.\.\.* are any other options used to supply the commit message, files
    to commit, etc\.

    The \(dis\)advantages are now reversed\.

    We have no superflous commit, only what is actually developed\. The work is
    hidden until we commit to make our first commit\.

    We may forget to use __\-\-branch NAME\_OF\_NEW\_BRANCH__ and then have to
    correct that oversight via the fossil web interface \(I am currently unaware
    of ways of doing such from the command line, although some magic
    incantantion of __fossil tag create__ may work\)\.

    It helps to keep awareness, like checking before any commit that we are on
    the desired branch\.

  - *Merging a branch into trunk*

    Be aware of where you are \(see first definition\)\.

    Ensure that you have clean checkout \(see second definition\)\. In the
    full\-blown sequence \(zig\-zag\) it is *required*, due to the merging from
    trunk\. In the shorter sequence it is only desired\. That said, keeping the
    checkout clean before any major operations is a good habit to have, in my
    opinion\.

    The full\-blown sequencing with checks all the way is to

      1. Validate the checkout, i\.e\. last commit on your branch\. Run the full
         test suite and other validations, fix all the issues which have cropped
         up\.

      1. Merge the latest state of the *trunk* \(see next definition\)\.

      1. Validate the checkout again\. The incoming trunk changes may have broken
         something now\. Do any required fixes\.

      1. Now merge to the trunk using

             fossil update trunk
             fossil merge --integrate YOUR_BRANCH

      1. At this point the checkout should be in the same state as at the end of
         point \(3\) above, because we resolved any issues with the trunk already\.
         Thus a simple

             fossil commit ...

         should be sufficient now to commit the merge back and close the branch
         \(due to the __\-\-integrate__ we used on the merge\)\.

         The more paranoid may validate the checkout a third time before
         commiting\.

    I call this a *zig\-zag merge* because of how the arrows look in the
    timeline, from trunk to feature branch for the first merge, and then back
    for the final merge\.

    A less paranoid can do what I call a *simple merge*, which moves step \(2\)
    after step \(4\) and skips step \(3\) entirely\. The resulting shorter sequence
    is

      1. Validate

      1. Merge to trunk

      1. Validate again

      1. Commit to trunk

    The last step after either zig\-zag or plain merge is to

        fossil sync

    This saves our work to the remote side, and further gives us any other work
    done while we were doing our merge\. It especially allows us to check if we
    raced somebody else, resulting in a split trunk\.

    When that happens we should coordinate with the other developer on who fixes
    the split, to ensure that we do not race each other again\.

  - *Merging from trunk*

    Be aware of where you are \(see first definition\)\.

    Ensure that you have clean checkout \(see second definition\)\. It is
    *required*\.

    In most situations you want to import the latest commit of branch *trunk*
    \(or other origin\)\. To get it use

        fossil pull

    With that done we can now import this commit into our current branch with

        fossil merge trunk

    Even if __[fossil](\.\./\.\./\.\./index\.md\#fossil)__ does not report any
    conflicts it is a good idea to check that the operation has not broken the
    new and/or changed functionality we are working on\.

    With the establishment of a good merge we then save the state with

        fossil commit ...

    before continuing development\.

## <a name='subsection7'></a>Version numbers

In Tcllib all changes to a package have to come with an increment of its version
number\. What part is incremented \(patchlevel, minor, major version\) depends on
the kind of change made\. With multiple changes in a commit the highest "wins"\.

When working in a development branch the version change can be deferred until it
is time to merge, and then has to cover all the changes in the branch\.

Below a list of the kinds of changes and their associated version increments:

  - *D \- documentation*

    No increment

  - *T \- testsuite*

    No increment

  - *B \- bugfix*

    Patchlevel

  - *I \- implementation tweak*

    Patchlevel

  - *P \- performance tweak*

    Patchlevel

  - *E \- backward\-compatible extension*

    Minor

  - *API \- incompatible change*

    Major

Note that a commit containing a version increment has to mention the new version
number in its commit message, as well as the kind of change which caused it\.

Note further that the version number of a package currently exists in three
places\. An increment has to update all of them:

  1. The package implementation\.

  1. The package index \("pkgIndex\.tcl"\)

  1. The package documentation\.

The "sak\.tcl" command __validate version__ helps finding discrepancies
between the first two\. All the other __validate__ methods are also of
interest to any developer\. Invoke it with

    sak.tcl help validate

to see their documentation\.

# <a name='section4'></a>Structural Overview

## <a name='subsection8'></a>Main Directories

The main directories in the Tcllib toplevel directory and of interest to a
developer are:

  - "modules"

    Each child directory represents one or more packages\. In the case of the
    latter the packages are usually related in some way\. Examples are "base64",
    "math", and "struct", with loose \(base64\) to strong \(math\) relations between
    the packages in the directory\.

  - "apps"

    This directory contains all the installable applications, with their
    documentation\. Note that this directory is currently *not* split into
    sub\-directories\.

  - "examples"

    Each child directory "foo" contains one or more example application for the
    packages in "modules/foo"\. These examples are generally not polished enough
    to be considered for installation\.

## <a name='subsection9'></a>More Directories

  - "config"

    This directory contains files supporting the Unix build system, i\.e\.
    "configure" and "Makefile\.in"\.

  - "devdoc"

    This directories contains the doctools sources for the global documentation,
    like this document and its sibling guides\.

  - "embedded"

    This directory contains the entire documentation formatted for
    *[HTML](\.\./\.\./\.\./index\.md\#html)* and styled to properly mix into the
    web site generated by fossil for the repository\.

    This is the documentation accessible from the Tcllib home directory,
    represented in the repository as "embedded/index\.md"\.

  - "idoc"

    This directory contains the entire documentation formatted for
    *[nroff](\.\./\.\./\.\./index\.md\#nroff)* and
    *[HTML](\.\./\.\./\.\./index\.md\#html)*, the latter without any styling\. This
    is the documentation which will be installed\.

  - "support"

    This directory contains the sources of internal packages and utilities used
    in the implementation of the "installer\.tcl" and "sak\.tcl" scripts/tools\.

## <a name='subsection10'></a>Top Files

  - "aclocal\.m4"

  - "configure"

  - "configure\.in"

  - "Makefile\.in"

    These four files comprise the Unix build system layered on top of the
    "installer\.tcl" script\.

  - "installer\.tcl"

    The Tcl\-based installation script/tool\.

  - "project\.shed"

    Configuration file for *Sean Wood*'s
    __[PracTcl](\.\./modules/practcl/practcl\.md)__ buildsystem\.

  - "sak\.tcl"

    This is the main tool for developers and release managers, the *Swiss Army
    Knife* of management operations on the collection\.

  - "ChangeLog"

    The log of changes to the global support, when the sources were held in
    *[CVS](\.\./\.\./\.\./index\.md\#cvs)*\. Not relevant any longer with the
    switch to the *[fossil](\.\./\.\./\.\./index\.md\#fossil)* SCM\.

  - "license\.terms"

    The license in plain ASCII\. See also *[Tcllib \-
    License](tcllib\_license\.md)* for the nicely formatted form\. The text is
    identical\.

  - "README\.md"

  - "\.github/CONTRIBUTING\.md"

  - "\.github/ISSUE\_TEMPLATE\.md"

  - "\.github/PULL\_REQUEST\_TEMPLATE\.md"

    These markdown\-formatted documents are used and shown by the github mirror
    of these sources, pointing people back to the official location and issue
    trackers\.

  - "DESCRIPTION\.txt"

  - "STATUS"

  - "tcllib\.spec"

  - "tcllib\.tap"

  - "tcllib\.yml"

    ????

## <a name='subsection11'></a>File Types

The most common file types, by file extension, are:

  - "\.tcl"

    Tcl code for a package, application, or example\.

  - "\.man"

    Doctools\-formatted documentation, usually for a package\.

  - "\.test"

    Test suite for a package, or part of\. Based on __tcltest__\.

  - "\.bench"

    Performance benchmarks for a package, or part of\. Based on "modules/bench"\.

  - "\.pcx"

    Syntax rules for *TclDevKit*'s __tclchecker__\. Using these rules
    allows the checker to validate the use of commands of a Tcllib package
    __foo__ without having to scan the "\.tcl" files implementing it\.

# <a name='section5'></a>Testsuite Tooling

Testsuites in Tcllib are based on Tcl's standard test package __tcltest__,
plus utilities found in the directory "modules/devtools"

Tcllib developers invoke the suites through the __test run__ method of the
"sak\.tcl" tool, with other methods of __[test](\.\./\.\./\.\./index\.md\#test)__
providing management operations, for example setting a list of standard Tcl
shells to use\.

## <a name='subsection12'></a>Invoke the testsuites of a specific module

Invoke either

    ./sak.tcl test run foo

or

    ./sak.tcl test run modules/foo

to invoke the testsuites found in a specific module "foo"\.

## <a name='subsection13'></a>Invoke the testsuites of all modules

Invoke the tool without a module name, i\.e\.

    ./sak.tcl test run

to invoke the testsuites of all modules\.

## <a name='subsection14'></a>Detailed Test Logs

In all the previous examples the test runner will write a combination of
progress display and testsuite log to the standard output, showing for each
module only the tests that passed or failed and how many of each in a summary at
the end\.

To get a detailed log, it is necessary to invoke the test runner with additional
options\.

For one:

    ./sak.tcl test run --log LOG foo

While this shows the same short log on the terminal as before, it also writes a
detailed log to the file "LOG\.log", and excerpts to other files \("LOG\.summary",
"LOG\.failures", etc\.\)\.

For two:

    ./sak.tcl test run -v foo

This writes the detailed log to the standard output, instead of the short log\.

Regardless of form, the detailed log contains a list of all test cases executed,
which failed, and how they failed \(expected versus actual results\)\.

## <a name='subsection15'></a>Shell Selection

By default the test runner will use all the Tcl shells specified via __test
add__ to invoke the specified testsuites, if any\. If no such are specified it
will fall back to the Tcl shell used to run the tool itself\.

Use option __\-\-shell__ to explicitly specify the Tcl shell to use, like

    ./sak.tcl test run --shell /path/to/tclsh ...

## <a name='subsection16'></a>Help

Invoke the tool as

    ./sak.tcl help test

to see the detailed help for all methods of
__[test](\.\./\.\./\.\./index\.md\#test)__, and the associated options\.

# <a name='section6'></a>Documentation Tooling

The standard format used for documentation of packages and other things in
Tcllib is *[doctools](\.\./\.\./\.\./index\.md\#doctools)*\. Its supporting
packages are a part of Tcllib, see the directories "modules/doctools" and
"modules/dtplite"\. The latter is an application package, with the actual
application "apps/dtplite" a light wrapper around it\.

Tcllib developers gain access to these through the __doc__ method of the
"sak\.tcl" tool, another \(internal\) wrapper around the "modules/dtplite"
application package\.

## <a name='subsection17'></a>Generate documentation for a specific module

Invoke either

    ./sak.tcl doc html foo

or

    ./sak.tcl doc html modules/foo

to generate HTML for the documentation found in the module "foo"\. Instead of
__html__ any other supported format can be used here, of course\.

The generated formatted documentation will be placed into a directory "doc" in
the current working directory\.

## <a name='subsection18'></a>Generate documentation for all modules

Invoke the tool without a module name, i\.e\.

    ./sak.tcl doc html

to generate HTML for the documentation found in all modules\. Instead of
__html__ any other supported format can be used here, of course\.

The generated formatted documentation will be placed into a directory "doc" in
the current working directory\.

## <a name='subsection19'></a>Available output formats, help

Invoke the tool as

    ./sak.tcl help doc

to see the entire set of supported output formats which can be generated\.

## <a name='subsection20'></a>Validation without output

Note the special format __validate__\.

Using this value as the name of the format to generate forces the tool to simply
check that the documentation is syntactically correct, without generating actual
output\.

Invoke it as either

    ./sak.tcl doc validate (modules/)foo

or

    ./sak.tcl doc validate

to either check the packages of a specific module or check all of them\.

# <a name='section7'></a>Notes On Writing A Testsuite

While previous sections talked about running the testsuites for a module and the
packages therein, this has no meaning if the module in question has no
testsuites at all\.

This section gives a very basic overview on possible methodologies for writing
tests and testsuites\.

First there are "drudgery" tests\. Written to check absolutely basic assumptions
which should never fail\.

For example for a command FOO taking two arguments, three tests calling it with
zero, one, and three arguments\. The basic checks that the command fails if it
has not enough arguments, or too many\.

After that come the tests checking things based on our knowledge of the command,
about its properties and assumptions\. Some examples based on the graph
operations added during Google's Summer of Code 2009 are:

  - The BellmanFord command in struct::graph::ops takes a *startnode* as
    argument, and this node should be a node of the graph\. This equals one test
    case checking the behavior when the specified node is not a node of the
    graph\.

    This often gives rise to code in the implementation which explicitly checks
    the assumption and throws an understandable error, instead of letting the
    algorithm fail later in some weird non\-deterministic way\.

    It is not always possible to do such checks\. The graph argument for example
    is just a command in itself, and while we expect it to exhibit a certain
    interface, i\.e\. a set of sub\-commands aka methods, we cannot check that it
    has them, except by actually trying to use them\. That is done by the
    algorithm anyway, so an explicit check is just overhead we can get by
    without\.

  - IIRC one of the distinguishing characteristic of either BellmanFord and/or
    Johnson is that they are able to handle negative weights\. Whereas Dijkstra
    requires positive weights\.

    This induces \(at least\) three testcases \.\.\. Graph with all positive weights,
    all negative, and a mix of positive and negative weights\. Thinking further
    does the algorithm handle the weight __0__ as well ? Another test case,
    or several, if we mix zero with positive and negative weights\.

  - The two algorithms we are currently thinking about are about distances
    between nodes, and distance can be 'Inf'inity, i\.e\. nodes may not be
    connected\. This means that good test cases are

      1. Strongly connected graph

      1. Connected graph

      1. Disconnected graph\.

    At the extremes of strongly connected and disconnected we have the fully
    connected graphs and graphs without edges, only nodes, i\.e\. completely
    disconnected\.

  - IIRC both of the algorithms take weighted arcs, and fill in a default if
    arcs are left unweighted in the input graph\.

    This also induces three test cases:

      1. Graph will all arcs with explicit weights\.

      1. Graph without weights at all\.

      1. Graph with mixture of weighted and unweighted graphs\.

What was described above via examples is called *black\-box* testing\. Test
cases are designed and written based on the developer's knowledge of the
properties of the algorithm and its inputs, without referencing a particular
implementation\.

Going further, a complement to *black\-box* testing is *white\-box*\. For this
we know the implementation of the algorithm, we look at it and design our tests
cases so that they force the code through all possible paths in the
implementation\. Wherever a decision is made we have a test case forcing a
specific direction of the decision, for all possible combinations and
directions\. It is easy to get a combinatorial explosion in the number of needed
test\-cases\.

In practice I often hope that the black\-box tests I have made are enough to
cover all the paths, obviating the need for white\-box tests\.

The above should be enough to make it clear that writing tests for an algorithm
takes at least as much time as coding the algorithm, and often more time\. Much
more time\. See for example also
[http://sqlite\.org/testing\.html](http://sqlite\.org/testing\.html), a writeup
on how the Sqlite database engine is tested\. Another article of interest might
be
[https://www\.researchgate\.net/publication/298896236](https://www\.researchgate\.net/publication/298896236)\.
While geared to a particular numerical algorithm it still shows that even a
simple\-looking algorithm can lead to an incredible number of test cases\.

An interesting connection is to documentation\. In one direction, the properties
checked with black\-box testing are exactly the properties which should be
documented in the algorithm's man page\. And conversely, the documentation of the
properties of an algorithm makes a good reference to base the black\-box tests
on\.

In practice test cases and documentation often get written together,
cross\-influencing each other\. And the actual writing of test cases is a mix of
black and white box, possibly influencing the implementation while writing the
tests\. Like writing a test for a condition like *startnode not in input graph*
serving as reminder to put a check for this condition into the code\.

# <a name='section8'></a>Installation Tooling

A last thing to consider when adding a new package to the collection is
installation\.

How to *use* the "installer\.tcl" script is documented in *[Tcllib \- The
Installer's Guide](tcllib\_installer\.md)*\.

Here we document how to extend said installer so that it may install new
package\(s\) and/or application\(s\)\.

In most cases only a single file has to be modified, the
"support/installation/modules\.tcl" holding one command per module and
application to install\.

The relevant commands are:

  - <a name='1'></a>__[Module](\.\./\.\./\.\./index\.md\#module)__ *name* *code\-action* *doc\-action* *example\-action*

    Install the packages of module *name*, found in "modules/*name*"\.

    The *code\-action* is responsible for installing the packages and their
    index\. The system currently provides

      * __\_tcl__

        Copy all "\.tcl" files found in "modules/*name*" into the installation\.

      * __\_tcr__

        As __\_tcl__, copy the "\.tcl" files found in the subdirectories of
        "modules/*name*" as well\.

      * __\_tci__

        As __\_tcl__, and copy the "tclIndex\.tcl" file as well\.

      * __\_msg__

        As __\_tcl__, and copy the subdirectory "msgs" as well\.

      * __\_doc__

        As __\_tcl__, and copy the subdirectory "mpformats" as well\.

      * __\_tex__

        As __\_tcl__, and copy "\.tex" files as well\.

    The *doc\-action* is responsible for installing the package documentation\.
    The system currently provides

      * __\_null__

        No documentation available, do nothing\.

      * __\_man__

        Process the "\.man" files found in "modules/*name*" and install the
        results \(nroff and/or HTML\) in the proper location, as given to the
        installer\.

        This is actually a fallback, normally the installer uses the pre\-made
        formatted documentation found under "idoc"\.

    The *example\-action* is responsible for installing the examples\. The
    system currently provides

      * __\_null__

        No examples available, do nothing\.

      * __\_exa__

        Copy the the directory "examples/*name*" recursively to the install
        location for examples\.

  - <a name='2'></a>__[Application](\.\./\.\./\.\./index\.md\#application)__ *name*

    Install the application with *name*, found in "apps"\.

  - <a name='3'></a>__Exclude__ *name*

    This command signals to the installer which of the listed modules to *not*
    install\. I\.e\. they name the deprecated modules of Tcllib\.

If, and only if the above actions are not suitable for the new module then a
second file has to be modified, "support/installation/actions\.tcl"\.

This file contains the implementations of the available actions, and is the
place where any custom action needed to handle the special circumstances of
module has to be added\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<












































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/devdoc/tcllib_installer.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340

[//000000001]: # (tcllib\_install\_guide \- )
[//000000002]: # (Generated from file 'tcllib\_installer\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcllib\_install\_guide\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcllib\_install\_guide \- Tcllib \- The Installer's Guide

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [Requisites](#section2)

      - [Tcl](#subsection1)

      - [Critcl](#subsection2)

  - [Build & Installation Instructions](#section3)

      - [Installing on Unix](#subsection3)

      - [Installing on Windows](#subsection4)

      - [Critcl & Accelerators](#subsection5)

      - [Tooling](#subsection6)

# <a name='description'></a>DESCRIPTION

Welcome to Tcllib, the Tcl Standard Library\. Note that Tcllib is not a package
itself\. It is a collection of \(semi\-independent\)
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* packages that provide utility functions
useful to a large collection of Tcl programmers\.

The audience of this document is anyone wishing to build and install the
packages found in Tcllib, for either themselves, or others\.

For developers intending to work on the packages themselves we additionally
provide

  1. *[Tcllib \- The Developer's Guide](tcllib\_devguide\.md)*\.

Please read *[Tcllib \- How To Get The Sources](tcllib\_sources\.md)* first,
if that was not done already\. Here we assume that the sources are already
available in a directory of your choice\.

# <a name='section2'></a>Requisites

Before Tcllib can be build and used a number of requisites must be installed\.
These are:

  1. The scripting language Tcl\. For details see [Tcl](#subsection1)\.

  1. Optionally, the __critcl__ package \(C embedding\) for
     __[Tcl](\.\./\.\./\.\./index\.md\#tcl)__\. For details see __CriTcl__\.

This list assumes that the machine where Tcllib is to be installed is
essentially clean\. Of course, if parts of the dependencies listed below are
already installed the associated steps can be skipped\. It is still recommended
to read their sections though, to validate that the dependencies they talk about
are indeed installed\.

## <a name='subsection1'></a>Tcl

As we are installing a number of Tcl packages and applications it should be
pretty much obvious that a working installation of Tcl itself is needed, and I
will not belabor the point\.

Out of the many possibilities use whatever you are comfortable with, as long as
it provides at the very least Tcl 8\.2, or higher\. This may be a Tcl installation
provided by your operating system distribution, from a distribution\-independent
vendor, or built by yourself\.

*Note* that the packages in Tcllib have begun to require 8\.4, 8\.5, and even
8\.6\. Older versions of Tcl will not be able to use such packages\. Trying to use
them will result in *package not found* errors, as their package index files
will not register them in versions of the core unable to use them\.

Myself, I used \(and still use\) [ActiveState's](http://www\.activestate\.com)
ActiveTcl 8\.5 distribution during development, as I am most familiar with it\.

*\(Disclosure: I, Andreas Kupries, worked for ActiveState until 2016,
maintaining ActiveTcl and TclDevKit for them\)\.*\. I am currently working for
SUSE Software Canada ULC, although not in Tcl\-related areas\.

This distribution can be found at
[http://www\.activestate\.com/activetcl](http://www\.activestate\.com/activetcl)\.
Retrieve the archive of ActiveTcl 8\.5 \(or higher\) for your platform and install
it as directed by ActiveState\.

For those wishing to build and install Tcl on their own, the relevant sources
can be found at

  - Tcl

    [http://core\.tcl\-lang\.org/tcl/](http://core\.tcl\-lang\.org/tcl/)

together with the necessary instructions on how to build it\.

If there are problems with building, installing, or using Tcl, please file a
ticket against *[Tcl](\.\./\.\./\.\./index\.md\#tcl)*, or the vendor of your
distribution, and *not* *[Tcllib](\.\./\.\./\.\./index\.md\#tcllib)*\.

## <a name='subsection2'></a>Critcl

The __critcl__ tool is an *optional* dependency\.

It is only required when trying to build the C\-based *accelerators* for a
number of packages, as explained in [Critcl & Accelerators](#subsection5)

Tcllib's build system looks for it in the , using the name __critcl__\. This
is for Unix\. On Windows on the other hand the search is more complex\. First we
look for a proper application __critcl\.exe__\. When that is not found we look
for a combination of interpreter \(__tclkitsh\.exe__, __tclsh\.exe__\) and
starkit \(__critcl\.kit__, __critcl__\) instead\. *Note* that the choice
of starkit can be overriden via the environment variable \.

Tcllib requires Critcl version 2 or higher\.

The github repository providing releases of version 2 and higher, and the
associated sources, can be found at
[http://andreas\-kupries\.github\.com/critcl](http://andreas\-kupries\.github\.com/critcl)\.

Any branch of the repository can be used \(if not using the prebuild starkit or
starpack\), although the use of the stable branch *master* is recommended\.

At the above url is also an explanation on how to build and install Critcl,
including a list of its dependencies\.

Its instructions will not be repeated here\. If there are problems with these
directions please file a ticket against the *Critcl* project, and not Tcllib\.

# <a name='section3'></a>Build & Installation Instructions

As Tcllib is mainly a bundle of packages written in pure Tcl building it is the
same as installing it\. The exceptions to this have their own subsection,
[Critcl & Accelerators](#subsection5), later on\.

Before that however comes the standard case, differentiated by the platforms
with material differences in the instruction, i\.e\. *Unix*\-like, versus
*Windows*\.

Regarding the latter it should also be noted that it is possible set up an
*Unix*\-like environment using projects like *MSYS*, *Cygwin*, and others\.
In that case the user has the choice of which instructions to follow\.

Regardless of environment or platform, a suitable
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* has to be installed, and its __tclsh__
should be placed on the \(*Unix*\) or associated with "\.tcl" files
\(*Windows*\)\.

## <a name='subsection3'></a>Installing on Unix

For *Unix*\-like environments Tcllib comes with the standard set of files to
make

    ./configure
    make install

a suitable way of installing it\. This is a standard non\-interactive install
automatically figuring out where to place everything, i\.e\. packages,
applications, and the manpages\.

To get a graphical installer invoke

    ./installer.tcl

instead\.

## <a name='subsection4'></a>Installing on Windows

In a Windows environment we have the __installer\.tcl__ script to perform
installation\.

If the desired __tclsh__ is associated "\.tcl" files then double\-clicking /
opening the __installer\.tcl__ is enough to invoke it in graphical mode\. This
assumes that *[Tk](\.\./\.\./\.\./index\.md\#tk)* is installed and available as
well\.

Without *[Tk](\.\./\.\./\.\./index\.md\#tk)* the only way to invoke the installer
are to open a DOS window, i\.e\. __cmd\.exe__, and then to invoke

    ./installer.tcl

inside it\.

## <a name='subsection5'></a>Critcl & Accelerators

While the majority of Tcllib consists of packages written in pure Tcl a number
of packages also have *accelerators* associated with them\. These are
__critcl__\-based C packages whose use will boost the performance of the
packages using them\. These accelerators are optional, and they are not built by
default\. If they are built according to the instructions below then they will
also be installed as well\.

To build the accelerators the normally optional dependency on __critcl__
becomes required\.

To build and install Tcllib with the accelerators in a Unix\-like environment
invoke:

    ./configure
    make critcl  # Builds the shared library and package holding
                 # the accelerators, tcllibc
    make install # Installs all packages, including the new tcllibc.

The underlying tool is "sak\.tcl" in the toplevel directory of Tcllib and the
command __make critcl__ is just a wrapper around

    ./sak.tcl critcl

Therefore in a Windows environment instead invoke

    ./sak.tcl critcl
    ./installer.tcl

from within a DOS window, i\.e\. __cmd\.exe__\.

## <a name='subsection6'></a>Tooling

The core of Tcllib's build system is the script "installer\.tcl" found in the
toplevel directory of a checkout or release\.

The

    configure ; make install

setup available to developers on Unix\-like systems is just a wrapper around it\.
To go beyond the standard embodied in the wrapper it is necessary to directly
invoke this script\.

On Windows system using it directly is the only way to invoke it\.

For basic help invoke it as

    ./installer.tcl -help

This will print a short list of all the available options to the standard output
channel\.

The commands associated with the various *install* targets in the
*Makefile\.in* for Unix can be used as additional examples on how to use this
tool as well\.

The installer can operate in GUI and CLI modes\. By default it chooses the mode
automatically, based on if the Tcl package
__[Tk](\.\./\.\./\.\./index\.md\#tk)__ can be used or not\. The option
__\-no\-gui__ can be used to force CLI mode\.

Note that it is possible to specify options on the command line even if the
installer ultimatively selects GUI mode\. In that case the hardwired defaults and
the options determine the data presented to the user for editing\.

The installer will select a number of defaults for the locations of packages,
examples, and documentation, and also the format of the documentation\. The user
can overide these defaults in the GUI, or by specifying additional options\. The
defaults depend on the platform detected \(Unix/Windows\) and on the __tclsh__
executable used to run the installer\.

*Options*

  - __\-help__

    Show the list of options explained here on the standard output channel and
    exit\.

  - __\+excluded__

    Include deprecated packages in the installation\.

  - __\-no\-gui__

    Force command line operation of the installer

  - __\-no\-wait__

    In CLI mode the installer will by default ask the user to confirm that the
    chosen configuration \(destination paths, things to install\) is correct
    before performing any action\. Using this option causes the installer to skip
    this query and immediately jump to installation\.

  - __\-app\-path__ *path*

  - __\-example\-path__ *path*

  - __\-html\-path__ *path*

  - __\-nroff\-path__ *path*

  - __\-pkg\-path__ *path*

    Declare the destination paths for the applications, examples, html
    documentation, nroff manpages, and packages\. The defaults are derived from
    the location of the __tclsh__ used to run the installer\.

  - __\-dry\-run__

  - __\-simulate__

    Run the installer without modifying the destination directories\.

  - __\-apps__

  - __\-no\-apps__

  - __\-examples__

  - __\-no\-examples__

  - __\-pkgs__

  - __\-no\-pkgs__

  - __\-html__

  - __\-no\-html__

  - __\-nroff__

  - __\-no\-nroff__

    \(De\)activate the installation of applications, examples, packages, html
    documentation, and nroff manpages\.

    Applications, examples, and packages are installed by default\.

    On Windows the html documentation is installed by default\.

    On Unix the nroff manpages are installed by default\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<








































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/devdoc/tcllib_license.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

[//000000001]: # (tcllib\_license \- )
[//000000002]: # (Generated from file 'tcllib\_license\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcllib\_license\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcllib\_license \- Tcllib \- License

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [License](#section2)

# <a name='description'></a>DESCRIPTION

Welcome to Tcllib, the Tcl Standard Library\. Note that Tcllib is not a package
itself\. It is a collection of \(semi\-independent\)
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* packages that provide utility functions
useful to a large collection of Tcl programmers\.

The collection is under the BSD license\.

# <a name='section2'></a>License

This software is copyrighted by Ajuba Solutions and other parties\. The following
terms apply to all files associated with the software unless explicitly
disclaimed in individual files\.

The authors hereby grant permission to use, copy, modify, distribute, and
license this software and its documentation for any purpose, provided that
existing copyright notices are retained in all copies and that this notice is
included verbatim in any distributions\. No written agreement, license, or
royalty fee is required for any of the authorized uses\. Modifications to this
software may be copyrighted by their authors and need not follow the licensing
terms described here, provided that the new terms are clearly indicated on the
first page of each file where they apply\.

IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY FOR DIRECT,
INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE
OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN IF THE
AUTHORS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE\.

THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE, AND NON\-INFRINGEMENT\. THIS SOFTWARE IS PROVIDED ON AN "AS
IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO PROVIDE
MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS\.

GOVERNMENT USE: If you are acquiring this software on behalf of the U\.S\.
government, the Government shall have only "Restricted Rights" in the software
and related documentation as defined in the Federal Acquisition Regulations
\(FARs\) in Clause 52\.227\.19 \(c\) \(2\)\. If you are acquiring the software on behalf
of the Department of Defense, the software shall be classified as "Commercial
Computer Software" and the Government shall have only "Restricted Rights" as
defined in Clause 252\.227\-7013 \(c\) \(1\) of DFARs\. Notwithstanding the foregoing,
the authors grant the U\.S\. Government and others acting in its behalf permission
to use and distribute the software in accordance with the terms specified in
this license\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































Deleted embedded/md/tcllib/files/devdoc/tcllib_releasemgr.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

[//000000001]: # (tcllib\_releasemgr \- )
[//000000002]: # (Generated from file 'tcllib\_releasemgr\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcllib\_releasemgr\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcllib\_releasemgr \- Tcllib \- The Release Manager's Guide

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [Tools](#section2)

  - [Tasks](#section3)

      - [Start a release candidate](#subsection1)

      - [Ready the candidate](#subsection2)

      - [Make it official](#subsection3)

      - [Distribute the release](#subsection4)

# <a name='description'></a>DESCRIPTION

Welcome to Tcllib, the Tcl Standard Library\. Note that Tcllib is not a package
itself\. It is a collection of \(semi\-independent\)
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* packages that provide utility functions
useful to a large collection of Tcl programmers\.

The audience of this document is the release manager for Tcllib, their deputies,
and anybody else interested in the task of creating an official release of
Tcllib for distribution\.

Please read *[Tcllib \- How To Get The Sources](tcllib\_sources\.md)* first,
if that was not done already\. Here we assume that the sources are already
available in a directory of your choice\.

# <a name='section2'></a>Tools

The "sak\.tcl" script in the toplevel directory of a Tcllib checkout is the one
tool used by the release manager to perform its [Tasks](#section3)\.

The main commands to be used are

    sak.tcl validate
    sak.tcl test run
    sak.tcl review
    sak.tcl readme
    sak.tcl localdoc
    sak.tcl release

More detail will be provided in the explanations of the various
[Tasks](#section3)\.

# <a name='section3'></a>Tasks

## <a name='subsection1'></a>Start a release candidate

todo: open a candidate for release

## <a name='subsection2'></a>Ready the candidate

todo: test, validate and check that the candidate is worthy of release fix
testsuites, possibly fix packages, documentation regenerate docs coordinate with
package maintainers wrt fixes big thing: going over the packages, classify
changes since last release to generate a nice readme\.

## <a name='subsection3'></a>Make it official

todo: finalize release, make candidate official

## <a name='subsection4'></a>Distribute the release

With the release made it has to be published and the world notified of its
existence\.

  1. Create a proper fossil event for the release, via
     [http://core\.tcl\-lang\.org/tcllib/eventedit](http://core\.tcl\-lang\.org/tcllib/eventedit)\.

     An [existing
     event](http://core\.tcl\-lang\.org/tcllib/event/dac0ddcd2e990234143196b4dc438fe01e7b9817)
     should be used as template\.

  1. Update a number of web locations:

       1) [Home
          page](http://core\.tcl\-lang\.org/tcllib/doc/trunk/embedded/index\.md)

       1) [Downloads](http://core\.tcl\-lang\.org/tcllib/wiki?name=Downloads)

       1) [Past
          Releases](http://core\.tcl\-lang\.org/tcllib/wiki?name=Past\+Releases)

       1) [http://www\.tcl\-lang\.org/home/release\.txt](http://www\.tcl\-lang\.org/home/release\.txt)

       1) [http://www\.tcl\-lang\.org/software/tcllib/\*\.tml](http://www\.tcl\-lang\.org/software/tcllib/\*\.tml)

       1) [http://wiki\.tcl\-lang\.org/page/Tcllib](http://wiki\.tcl\-lang\.org/page/Tcllib)

     The first location maps to the file "embedded/index\.md" in the repository
     itself, as such it can edited as part of the release process\. This is where
     reference to the new fossil event is added, as the new current release\.

     The next two locations are in the fossil tcllib wiki and require admin or
     wiki write permissions for
     [http://core\.tcl\-lang\.org/tcllib](http://core\.tcl\-lang\.org/tcllib)\.

     The last two locations require ssh access to
     [http://www\.tcl\-lang\.org](http://www\.tcl\-lang\.org) and permission to
     edit files in the web area\.

  1. \*\*\*TODO\*\*\* mailing lists and other places to send notes to\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
























































































































































































































































Deleted embedded/md/tcllib/files/devdoc/tcllib_sources.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

[//000000001]: # (tcllib\_sources \- )
[//000000002]: # (Generated from file 'tcllib\_sources\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (tcllib\_sources\(n\) 1 tcllib "")

<hr> [ <a href="../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../toc.md">Table Of Contents</a> &#124; <a
href="../../../index.md">Keyword Index</a> &#124; <a
href="../../../toc0.md">Categories</a> &#124; <a
href="../../../toc1.md">Modules</a> &#124; <a
href="../../../toc2.md">Applications</a> ] <hr>

# NAME

tcllib\_sources \- Tcllib \- How To Get The Sources

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Description](#section1)

  - [Source Location](#section2)

  - [Retrieval](#section3)

  - [Source Code Management](#section4)

# <a name='description'></a>DESCRIPTION

Welcome to Tcllib, the Tcl Standard Library\. Note that Tcllib is not a package
itself\. It is a collection of \(semi\-independent\)
*[Tcl](\.\./\.\./\.\./index\.md\#tcl)* packages that provide utility functions
useful to a large collection of Tcl programmers\.

The audience of this document is anyone wishing to either have just a look at
Tcllib's source code, or build the packages, or to extend and modify them\.

For builders and developers we additionally provide

  1. *[Tcllib \- The Installer's Guide](tcllib\_installer\.md)*\.

  1. *[Tcllib \- The Developer's Guide](tcllib\_devguide\.md)*\.

respectively\.

# <a name='section2'></a>Source Location

The official repository for Tcllib can be found at
[http://core\.tcl\-lang\.org/tcllib](http://core\.tcl\-lang\.org/tcllib)

# <a name='section3'></a>Retrieval

Assuming that you simply wish to look at the sources, or build a specific
revision, the easiest way of retrieving it is to:

  1. Log into this site, as "anonymous", using the semi\-random password in the
     captcha\.

  1. Go to the "Timeline"\.

  1. Choose the revision you wish to have\.

  1. Follow its link to its detailed information page\.

  1. On that page, choose either the "ZIP" or "Tarball" link to get a copy of
     this revision in the format of your choice\.

# <a name='section4'></a>Source Code Management

For the curious \(or a developer\-to\-be\), the sources are managed by the [Fossil
SCM](http://www\.fossil\-scm\.org)\. Binaries for popular platforms can be found
directly at its [download page](http://www\.fossil\-scm\.org/download\.html)\.

With that tool available the full history can be retrieved via:

    fossil clone  http://core.tcl-lang.org/tcllib  tcllib.fossil

followed by

    mkdir tcllib
    cd tcllib
    fossil open ../tcllib.fossil

to get a checkout of the head of the trunk\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































































Deleted embedded/md/tcllib/files/modules/aes/aes.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201

[//000000001]: # (aes \- Advanced Encryption Standard \(AES\))
[//000000002]: # (Generated from file 'aes\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2005, Pat Thoyts <patthoyts@users\.sourceforge\.net>)
[//000000004]: # (Copyright &copy; 2012\-2014, Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000005]: # (aes\(n\) 1\.2\.1 tcllib "Advanced Encryption Standard \(AES\)")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

aes \- Implementation of the AES block cipher

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [COMMANDS](#section2)

  - [PROGRAMMING INTERFACE](#section3)

  - [MODES OF OPERATION](#section4)

  - [EXAMPLES](#section5)

  - [REFERENCES](#section6)

  - [AUTHORS](#section7)

  - [Bugs, Ideas, Feedback](#section8)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.5  
package require aes ?1\.2\.1?  

[__::aes::aes__ ?*\-mode \[ecb&#124;cbc\]*? ?*\-dir \[encrypt&#124;decrypt\]*? *\-key keydata* ?*\-iv vector*? ?*\-hex*? ?*\-out channel*? ?*\-chunksize size*? \[ *\-in channel* &#124; ?__\-\-__? *data* \]](#1)  
[__::aes::Init__ *mode* *keydata* *iv*](#2)  
[__::aes::Encrypt__ *Key* *data*](#3)  
[__::aes::Decrypt__ *Key* *data*](#4)  
[__::aes::Reset__ *Key* *iv*](#5)  
[__::aes::Final__ *Key*](#6)  

# <a name='description'></a>DESCRIPTION

This is an implementation in Tcl of the Advanced Encryption Standard \(AES\) as
published by the U\.S\. National Institute of Standards and Technology \[1\]\. AES is
a 128\-bit block cipher with a variable key size of 128, 192 or 256 bits\. This
implementation supports ECB and CBC modes\.

# <a name='section2'></a>COMMANDS

  - <a name='1'></a>__::aes::aes__ ?*\-mode \[ecb&#124;cbc\]*? ?*\-dir \[encrypt&#124;decrypt\]*? *\-key keydata* ?*\-iv vector*? ?*\-hex*? ?*\-out channel*? ?*\-chunksize size*? \[ *\-in channel* &#124; ?__\-\-__? *data* \]

    Perform the __aes__ algorithm on either the data provided by the
    argument or on the data read from the *\-in* channel\. If an *\-out*
    channel is given then the result will be written to this channel\.

    The *\-key* option must be given\. This parameter takes a binary string of
    either 16, 24 or 32 bytes in length and is used to generate the key
    schedule\.

    The *\-mode* and *\-dir* options are optional and default to cbc mode and
    encrypt respectively\. The initialization vector *\-iv* takes a 16 byte
    binary argument which defaults to all zeros\. See [MODES OF
    OPERATION](#section4) for more about available modes and their uses\.

    AES is a 128\-bit block cipher\. This means that the data must be provided in
    units that are a multiple of 16 bytes\.

# <a name='section3'></a>PROGRAMMING INTERFACE

Internal state is maintained in an opaque structure that is returned from the
__Init__ function\. In ECB mode the state is not affected by the input but
for CBC mode some input dependent state is maintained and may be reset by
calling the __Reset__ function with a new initialization vector value\.

  - <a name='2'></a>__::aes::Init__ *mode* *keydata* *iv*

    Construct a new AES key schedule using the specified key data and the given
    initialization vector\. The initialization vector is not used with ECB mode
    but is important for CBC mode\. See [MODES OF OPERATION](#section4) for
    details about cipher modes\.

  - <a name='3'></a>__::aes::Encrypt__ *Key* *data*

    Use a prepared key acquired by calling __Init__ to encrypt the provided
    data\. The data argument should be a binary array that is a multiple of the
    AES block size of 16 bytes\. The result is a binary array the same size as
    the input of encrypted data\.

  - <a name='4'></a>__::aes::Decrypt__ *Key* *data*

    Decipher data using the key\. Note that the same key may be used to encrypt
    and decrypt data provided that the initialization vector is reset
    appropriately for CBC mode\.

  - <a name='5'></a>__::aes::Reset__ *Key* *iv*

    Reset the initialization vector\. This permits the programmer to re\-use a key
    and avoid the cost of re\-generating the key schedule where the same key data
    is being used multiple times\.

  - <a name='6'></a>__::aes::Final__ *Key*

    This should be called to clean up resources associated with *Key*\. Once
    this function has been called the key may not be used again\.

# <a name='section4'></a>MODES OF OPERATION

  - Electronic Code Book \(ECB\)

    ECB is the basic mode of all block ciphers\. Each block is encrypted
    independently and so identical plain text will produce identical output when
    encrypted with the same key\. Any encryption errors will only affect a single
    block however this is vulnerable to known plaintext attacks\.

  - Cipher Block Chaining \(CBC\)

    CBC mode uses the output of the last block encryption to affect the current
    block\. An initialization vector of the same size as the cipher block size is
    used to handle the first block\. The initialization vector should be chosen
    randomly and transmitted as the first block of the output\. Errors in
    encryption affect the current block and the next block after which the
    cipher will correct itself\. CBC is the most commonly used mode in software
    encryption\. This is the default mode of operation for this module\.

# <a name='section5'></a>EXAMPLES

    % set nil_block [string repeat \\0 16]
    % aes::aes -hex -mode cbc -dir encrypt -key $nil_block $nil_block
    66e94bd4ef8a2c3b884cfa59ca342b2e

    set Key [aes::Init cbc $sixteen_bytes_key_data $sixteen_byte_iv]
    append ciphertext [aes::Encrypt $Key $plaintext]
    append ciphertext [aes::Encrypt $Key $additional_plaintext]
    aes::Final $Key

# <a name='section6'></a>REFERENCES

  1. "Advanced Encryption Standard", Federal Information Processing Standards
     Publication 197, 2001
     \([http://csrc\.nist\.gov/publications/fips/fips197/fips\-197\.pdf](http://csrc\.nist\.gov/publications/fips/fips197/fips\-197\.pdf)\)

# <a name='section7'></a>AUTHORS

Thorsten Schloermann, Pat Thoyts

# <a name='section8'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *aes* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[blowfish\(n\)](\.\./blowfish/blowfish\.md), [des\(n\)](\.\./des/des\.md),
[md5\(n\)](\.\./md5/md5\.md), [sha1\(n\)](\.\./sha1/sha1\.md)

# <a name='keywords'></a>KEYWORDS

[aes](\.\./\.\./\.\./\.\./index\.md\#aes), [block
cipher](\.\./\.\./\.\./\.\./index\.md\#block\_cipher), [data
integrity](\.\./\.\./\.\./\.\./index\.md\#data\_integrity),
[encryption](\.\./\.\./\.\./\.\./index\.md\#encryption),
[security](\.\./\.\./\.\./\.\./index\.md\#security)

# <a name='category'></a>CATEGORY

Hashes, checksums, and encryption

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2005, Pat Thoyts <patthoyts@users\.sourceforge\.net>  
Copyright &copy; 2012\-2014, Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


















































































































































































































































































































































































































Deleted embedded/md/tcllib/files/modules/amazon-s3/S3.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514

[//000000001]: # (S3 \- Amazon S3 Web Service Utilities)
[//000000002]: # (Generated from file 'S3\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (2006,2008 Darren New\. All Rights Reserved\. See LICENSE\.TXT for terms\.)
[//000000004]: # (S3\(n\) 1\.0\.3 tcllib "Amazon S3 Web Service Utilities")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

S3 \- Amazon S3 Web Service Interface

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [ERROR REPORTING](#section2)

  - [COMMANDS](#section3)

  - [LOW LEVEL COMMANDS](#section4)

  - [HIGH LEVEL COMMANDS](#section5)

  - [LIMITATIONS](#section6)

  - [USAGE SUGGESTIONS](#section7)

  - [FUTURE DEVELOPMENTS](#section8)

  - [TLS Security Considerations](#section9)

  - [Bugs, Ideas, Feedback](#section10)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.5  
package require S3 ?1\.0\.3?  
package require sha1 1\.0  
package require md5 2\.0  
package require base64 2\.3  
package require xsxp 1\.0  

[__S3::Configure__ ?__\-reset__ *boolean*? ?__\-retries__ *integer*? ?__\-accesskeyid__ *idstring*? ?__\-secretaccesskey__ *idstring*? ?__\-service\-access\-point__ *FQDN*? ?__\-use\-tls__ *boolean*? ?__\-default\-compare__ *always&#124;never&#124;exists&#124;missing&#124;newer&#124;date&#124;checksum&#124;different*? ?__\-default\-separator__ *string*? ?__\-default\-acl__ *private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read&#124;keep&#124;calc*? ?__\-default\-bucket__ *bucketname*?](#1)  
[__S3::SuggestBucket__ ?*name*?](#2)  
[__S3::REST__ *dict*](#3)  
[__S3::ListAllMyBuckets__ ?__\-blocking__ *boolean*? ?__\-parse\-xml__ *xmlstring*? ?__\-result\-type__ *REST&#124;xml&#124;pxml&#124;dict&#124;names&#124;owner*?](#4)  
[__S3::PutBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*? ?__\-acl__ *\{\}&#124;private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read*?](#5)  
[__S3::DeleteBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*?](#6)  
[__S3::GetBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*? ?__\-parse\-xml__ *xmlstring*? ?__\-max\-count__ *integer*? ?__\-prefix__ *prefixstring*? ?__\-delimiter__ *delimiterstring*? ?__\-result\-type__ *REST&#124;xml&#124;pxml&#124;names&#124;dict*?](#7)  
[__S3::Put__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-file__ *filename*? ?__\-content__ *contentstring*? ?__\-acl__ *private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read&#124;calc&#124;keep*? ?__\-content\-type__ *contenttypestring*? ?__\-x\-amz\-meta\-\*__ *metadatatext*? ?__\-compare__ *comparemode*?](#8)  
[__S3::Get__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-compare__ *comparemode*? ?__\-file__ *filename*? ?__\-content__ *contentvarname*? ?__\-timestamp__ *aws&#124;now*? ?__\-headers__ *headervarname*?](#9)  
[__S3::Head__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-dict__ *dictvarname*? ?__\-headers__ *headersvarname*? ?__\-status__ *statusvarname*?](#10)  
[__S3::GetAcl__ ?__\-blocking__ *boolean*? ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-result\-type__ *REST&#124;xml&#124;pxml*?](#11)  
[__S3::PutAcl__ ?__\-blocking__ *boolean*? ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-acl__ *new\-acl*?](#12)  
[__S3::Delete__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-status__ *statusvar*?](#13)  
[__S3::Push__ ?__\-bucket__ *bucketname*? __\-directory__ *directoryname* ?__\-prefix__ *prefixstring*? ?__\-compare__ *comparemode*? ?__\-x\-amz\-meta\-\*__ *metastring*? ?__\-acl__ *aclcode*? ?__\-delete__ *boolean*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?](#14)  
[__S3::Pull__ ?__\-bucket__ *bucketname*? __\-directory__ *directoryname* ?__\-prefix__ *prefixstring*? ?__\-blocking__ *boolean*? ?__\-compare__ *comparemode*? ?__\-delete__ *boolean*? ?__\-timestamp__ *aws&#124;now*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?](#15)  
[__S3::Toss__ ?__\-bucket__ *bucketname*? __\-prefix__ *prefixstring* ?__\-blocking__ *boolean*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?](#16)  

# <a name='description'></a>DESCRIPTION

This package provides access to Amazon's Simple Storage Solution web service\.

As a quick summary, Amazon Simple Storage Solution provides a for\-fee web
service allowing the storage of arbitrary data as "resources" within "buckets"
online\. See [http://www\.amazonaws\.com/](http://www\.amazonaws\.com/) for
details on that system\. Access to the service is via HTTP \(SOAP or REST\)\. Much
of this documentation will not make sense if you're not familiar with the terms
and functionality of the Amazon S3 service\.

This package provides services for reading and writing the data items via the
REST interface\. It also provides some higher\-level operations\. Other packages in
the same distribution provide for even more functionality\.

Copyright 2006 Darren New\. All Rights Reserved\. NO WARRANTIES OF ANY TYPE ARE
PROVIDED\. COPYING OR USE INDEMNIFIES THE AUTHOR IN ALL WAYS\. This software is
licensed under essentially the same terms as Tcl\. See LICENSE\.txt for the terms\.

# <a name='section2'></a>ERROR REPORTING

The error reporting from this package makes use of $errorCode to provide more
details on what happened than simply throwing an error\. Any error caught by the
S3 package \(and we try to catch them all\) will return with an $errorCode being a
list having at least three elements\. In all cases, the first element will be
"S3"\. The second element will take on one of six values, with that element
defining the value of the third and subsequent elements\. S3::REST does not throw
an error, but rather returns a dictionary with the keys "error", "errorInfo",
and "errorCode" set\. This allows for reliable background use\. The possible
second elements are these:

  - usage

    The usage of the package is incorrect\. For example, a command has been
    invoked which requires the library to be configured before the library has
    been configured, or an invalid combination of options has been specified\.
    The third element of $errorCode supplies the name of the parameter that was
    wrong\. The fourth usually provides the arguments that were actually supplied
    to the throwing proc, unless the usage error isn't confined to a single
    proc\.

  - local

    Something happened on the local system which threw an error\. For example, a
    request to upload or download a file was made and the file permissions
    denied that sort of access\. The third element of $errorCode is the original
    $errorCode\.

  - socket

    Something happened with the socket\. It closed prematurely, or some other
    condition of failure\-to\-communicate\-with\-Amazon was detected\. The third
    element of $errorCode is the original $errorCode, or sometimes the message
    from fcopy, or \.\.\.?

  - remote

    The Amazon web service returned an error code outside the 2xx range in the
    HTTP header\. In other words, everything went as documented, except this
    particular case was documented not to work\. The third element is the
    dictionary returned from __::S3::REST__\. Note that S3::REST itself never
    throws this error, but just returns the dictionary\. Most of the higher\-level
    commands throw for convenience, unless an argument indicates they should
    not\. If something is documented as "not throwing an S3 remote error", it
    means a status return is set rather than throwing an error if Amazon returns
    a non\-2XX HTTP result code\.

  - notyet

    The user obeyed the documentation, but the author has not yet gotten around
    to implementing this feature\. \(Right now, only TLS support and sophisticated
    permissions fall into this category, as well as the S3::Acl command\.\)

  - xml

    The service has returned invalid XML, or XML whose schema is unexpected\. For
    the high\-level commands that accept service XML as input for parsing, this
    may also be thrown\.

# <a name='section3'></a>COMMANDS

This package provides several separate levels of complexity\.

  - The lowest level simply takes arguments to be sent to the service, sends
    them, retrieves the result, and provides it to the caller\. *Note:* This
    layer allows both synchronous and event\-driven processing\. It depends on the
    MD5 and SHA1 and base64 packages from Tcllib \(available at
    [http://core\.tcl\.tk/tcllib/](http://core\.tcl\.tk/tcllib/)\)\. Note that
    __S3::Configure__ is required for __S3::REST__ to work due to the
    authentication portion, so we put that in the "lowest level\."

  - The next layer parses the results of calls, allowing for functionality such
    as uploading only changed files, synchronizing directories, and so on\. This
    layer depends on the __TclXML__ package as well as the included
    __[xsxp](xsxp\.md)__ package\. These packages are package required
    when these more\-sophisticated routines are called, so nothing breaks if they
    are not correctly installed\.

  - Also included is a separate program that uses the library\. It provides code
    to parse $argv0 and $argv from the command line, allowing invocation as a
    tclkit, etc\. \(Not yet implmented\.\)

  - Another separate program provides a GUI interface allowing drag\-and\-drop and
    other such functionality\. \(Not yet implemented\.\)

  - Also built on this package is the OddJob program\. It is a separate program
    designed to allow distribution of computational work units over Amazon's
    Elastic Compute Cloud web service\.

The goal is to have at least the bottom\-most layers implemented in pure Tcl
using only that which comes from widely\-available sources, such as Tcllib\.

# <a name='section4'></a>LOW LEVEL COMMANDS

These commands do not require any packages not listed above\. They talk directly
to the service, or they are utility or configuration routines\. Note that the
"xsxp" package was written to support this package, so it should be available
wherever you got this package\.

  - <a name='1'></a>__S3::Configure__ ?__\-reset__ *boolean*? ?__\-retries__ *integer*? ?__\-accesskeyid__ *idstring*? ?__\-secretaccesskey__ *idstring*? ?__\-service\-access\-point__ *FQDN*? ?__\-use\-tls__ *boolean*? ?__\-default\-compare__ *always&#124;never&#124;exists&#124;missing&#124;newer&#124;date&#124;checksum&#124;different*? ?__\-default\-separator__ *string*? ?__\-default\-acl__ *private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read&#124;keep&#124;calc*? ?__\-default\-bucket__ *bucketname*?

    There is one command for configuration, and that is __S3::Configure__\.
    If called with no arguments, it returns a dictionary of key/value pairs
    listing all current settings\. If called with one argument, it returns the
    value of that single argument\. If called with two or more arguments, it must
    be called with pairs of arguments, and it applies the changes in order\.
    There is only one set of configuration information per interpreter\.

    The following options are accepted:

      * __\-reset__ *boolean*

        By default, false\. If true, any previous changes and any changes on the
        same call before the reset option will be returned to default values\.

      * __\-retries__ *integer*

        Default value is 3\. If Amazon returns a 500 error, a retry after an
        exponential backoff delay will be tried this many times before finally
        throwing the 500 error\. This applies to each call to __S3::REST__
        from the higher\-level commands, but not to __S3::REST__ itself\. That
        is, __S3::REST__ will always return httpstatus 500 if that's what it
        receives\. Functions like __S3::Put__ will retry the PUT call, and
        will also retry the GET and HEAD calls used to do content comparison\.
        Changing this to 0 will prevent retries and their associated delays\. In
        addition, socket errors \(i\.e\., errors whose errorCode starts with "S3
        socket"\) will be similarly retried after backoffs\.

      * __\-accesskeyid__ *idstring*

      * __\-secretaccesskey__ *idstring*

        Each defaults to an empty string\. These must be set before any calls are
        made\. This is your S3 ID\. Once you sign up for an account, go to
        [http://www\.amazonaws\.com/](http://www\.amazonaws\.com/), sign in, go
        to the "Your Web Services Account" button, pick "AWS Access
        Identifiers", and your access key ID and secret access keys will be
        available\. All __S3::REST__ calls are authenticated\. Blame Amazon
        for the poor choice of names\.

      * __\-service\-access\-point__ *FQDN*

        Defaults to "s3\.amazonaws\.com"\. This is the fully\-qualified domain name
        of the server to contact for __S3::REST__ calls\. You should probably
        never need to touch this, unless someone else implements a compatible
        service, or you wish to test something by pointing the library at your
        own service\.

      * __\-slop\-seconds__ *integer*

        When comparing dates between Amazon and the local machine, two dates
        within this many seconds of each other are considered the same\. Useful
        for clock drift correction, processing overhead time, and so on\.

      * __\-use\-tls__ *boolean*

        Defaults to false\. This is not yet implemented\. If true,
        __S3::REST__ will negotiate a TLS connection to Amazon\. If false,
        unencrypted connections are used\.

      * __\-bucket\-prefix__ *string*

        Defaults to "TclS3"\. This string is used by
        __S3::SuggestBucketName__ if that command is passed an empty string
        as an argument\. It is used to distinguish different applications using
        the Amazon service\. Your application should always set this to keep from
        interfering with the buckets of other users of Amazon S3 or with other
        buckets of the same user\.

      * __\-default\-compare__ *always&#124;never&#124;exists&#124;missing&#124;newer&#124;date&#124;checksum&#124;different*

        Defaults to "always\." If no \-compare is specified on __S3::Put__,
        __S3::Get__, or __S3::Delete__, this comparison is used\. See
        those commands for a description of the meaning\.

      * __\-default\-separator__ *string*

        Defaults to "/"\. This is currently unused\. It might make sense to use
        this for __S3::Push__ and __S3::Pull__, but allowing resources
        to have slashes in their names that aren't marking directories would be
        problematic\. Hence, this currently does nothing\.

      * __\-default\-acl__ *private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read&#124;keep&#124;calc*

        Defaults to an empty string\. If no \-acl argument is provided to
        __S3::Put__ or __S3::Push__, this string is used \(given as the
        x\-amz\-acl header if not keep or calc\)\. If this is also empty, no
        x\-amz\-acl header is generated\. This is *not* used by __S3::REST__\.

      * __\-default\-bucket__ *bucketname*

        If no bucket is given to __S3::GetBucket__, __S3::PutBucket__,
        __S3::Get__, __S3::Put__, __S3::Head__, __S3::Acl__,
        __S3::Delete__, __S3::Push__, __S3::Pull__, or
        __S3::Toss__, and if this configuration variable is not an empty
        string \(and not simply "/"\), then this value will be used for the
        bucket\. This is useful if one program does a large amount of resource
        manipulation within a single bucket\.

  - <a name='2'></a>__S3::SuggestBucket__ ?*name*?

    The __S3::SuggestBucket__ command accepts an optional string as a prefix
    and returns a valid bucket containing the *name* argument and the Access
    Key ID\. This makes the name unique to the owner and to the application
    \(assuming the application picks a good *name* argument\)\. If no name is
    provided, the name from __S3::Configure__ *\-bucket\-prefix* is used\. If
    that too is empty \(which is not the default\), an error is thrown\.

  - <a name='3'></a>__S3::REST__ *dict*

    The __S3::REST__ command takes as an argument a dictionary and returns a
    dictionary\. The return dictionary has the same keys as the input dictionary,
    and includes additional keys as the result\. The presence or absence of keys
    in the input dictionary can control the behavior of the routine\. It never
    throws an error directly, but includes keys "error", "errorInfo", and
    "errorCode" if necessary\. Some keys are required, some optional\. The routine
    can run either in blocking or non\-blocking mode, based on the presense of
    __resultvar__ in the input dictionary\. This requires the
    *\-accesskeyid* and *\-secretaccesskey* to be configured via
    __S3::Configure__ before being called\.

    The possible input keys are these:

      * __verb__ *GET&#124;PUT&#124;DELETE&#124;HEAD*

        This required item indicates the verb to be used\.

      * __resource__ *string*

        This required item indicates the resource to be accessed\. A leading / is
        added if not there already\. It will be URL\-encoded for you if necessary\.
        Do not supply a resource name that is already URL\-encoded\.

      * ?__rtype__ *torrent&#124;acl*?

        This indicates a torrent or acl resource is being manipulated\. Do not
        include this in the __resource__ key, or the "?" separator will get
        URL\-encoded\.

      * ?__parameters__ *dict*?

        This optional dictionary provides parameters added to the URL for the
        transaction\. The keys must be in the correct case \(which is confusing in
        the Amazon documentation\) and the values must be valid\. This can be an
        empty dictionary or omitted entirely if no parameters are desired\. No
        other error checking on parameters is performed\.

      * ?__headers__ *dict*?

        This optional dictionary provides headers to be added to the HTTP
        request\. The keys must be in *lower case* for the authentication to
        work\. The values must not contain embedded newlines or carriage returns\.
        This is primarily useful for adding x\-amz\-\* headers\. Since
        authentication is calculated by __S3::REST__, do not add that header
        here\. Since content\-type gets its own key, also do not add that header
        here\.

      * ?__inbody__ *contentstring*?

        This optional item, if provided, gives the content that will be sent\. It
        is sent with a tranfer encoding of binary, and only the low bytes are
        used, so use \[encoding convertto utf\-8\] if the string is a utf\-8 string\.
        This is written all in one blast, so if you are using non\-blocking mode
        and the __inbody__ is especially large, you may wind up blocking on
        the write socket\.

      * ?__infile__ *filename*?

        This optional item, if provided, and if __inbody__ is not provided,
        names the file from which the body of the HTTP message will be
        constructed\. The file is opened for reading and sent progressively by
        \[fcopy\], so it should not block in non\-blocking mode even if the file is
        very large\. The file is transfered in binary mode, so the bytes on your
        disk will match the bytes in your resource\. Due to HTTP restrictions, it
        must be possible to use \[file size\] on this file to determine the size
        at the start of the transaction\.

      * ?__S3chan__ *channel*?

        This optional item, if provided, indicates the already\-open socket over
        which the transaction should be conducted\. If not provided, a connection
        is made to the service access point specified via __S3::Configure__,
        which is normally s3\.amazonaws\.com\. If this is provided, the channel is
        not closed at the end of the transaction\.

      * ?__outchan__ *channel*?

        This optional item, if provided, indicates the already\-open channel to
        which the body returned from S3 should be written\. That is, to retrieve
        a large resource, open a file, set the translation mode, and pass the
        channel as the value of the key outchan\. Output will be written to the
        channel in pieces so memory does not fill up unnecessarily\. The channel
        is not closed at the end of the transaction\.

      * ?__resultvar__ *varname*?

        This optional item, if provided, indicates that __S3::REST__ should
        run in non\-blocking mode\. The *varname* should be fully qualified with
        respect to namespaces and cannot be local to a proc\. If provided, the
        result of the __S3::REST__ call is assigned to this variable once
        everything has completed; use trace or vwait to know when this has
        happened\. If this key is not provided, the result is simply returned
        from the call to __S3::REST__ and no calls to the eventloop are
        invoked from within this call\.

      * ?__throwsocket__ *throw&#124;return*?

        This optional item, if provided, indicates that __S3::REST__ should
        throw an error if throwmode is throw and a socket error is encountered\.
        It indicates that __S3::REST__ should return the error code in the
        returned dictionary if a socket error is encountered and this is set to
        return\. If __throwsocket__ is set to *return* or if the call is
        not blocking, then a socket error \(i\.e\., an error whose error code
        starts with "S3 socket" will be returned in the dictionary as
        __error__, __errorInfo__, and __errorCode__\. If a foreground
        call is made \(i\.e\., __resultvar__ is not provided\), and this option
        is not provided or is set to *throw*, then
        __[error](\.\./\.\./\.\./\.\./index\.md\#error)__ will be invoked instead\.

    Once the call to __S3::REST__ completes, a new dict is returned, either
    in the *resultvar* or as the result of execution\. This dict is a copy of
    the original dict with the results added as new keys\. The possible new keys
    are these:

      * __error__ *errorstring*

      * __errorInfo__ *errorstring*

      * __errorCode__ *errorstring*

        If an error is caught, these three keys will be set in the result\. Note
        that __S3::REST__ does *not* consider a non\-2XX HTTP return code
        as an error\. The __errorCode__ value will be formatted according to
        the [ERROR REPORTING](#section2) description\. If these are present,
        other keys described here might not be\.

      * __httpstatus__ *threedigits*

        The three\-digit code from the HTTP transaction\. 2XX for good, 5XX for
        server error, etc\.

      * __httpmessage__ *text*

        The textual result after the status code\. "OK" or "Forbidden" or etc\.

      * __outbody__ *contentstring*

        If *outchan* was not specified, this key will hold a reference to the
        \(unencoded\) contents of the body returned\. If Amazon returned an error
        \(a la the httpstatus not a 2XX value\), the error message will be in
        __outbody__ or written to __outchan__ as appropriate\.

      * __outheaders__ *dict*

        This contains a dictionary of headers returned by Amazon\. The keys are
        always lower case\. It's mainly useful for finding the x\-amz\-meta\-\*
        headers, if any, although things like last\-modified and content\-type are
        also useful\. The keys of this dictionary are always lower case\. Both
        keys and values are trimmed of extraneous whitespace\.

# <a name='section5'></a>HIGH LEVEL COMMANDS

The routines in this section all make use of one or more calls to
__S3::REST__ to do their work, then parse and manage the data in a
convenient way\. All these commands throw errors as described in [ERROR
REPORTING](#section2) unless otherwise noted\.

In all these commands, all arguments are presented as name/value pairs, in any
order\. All the argument names start with a hyphen\.

There are a few options that are common to many of the commands, and those
common options are documented here\.

  - __\-blocking__ *boolean*

    If provided and specified as false, then any calls to __S3:REST__ will
    be non\-blocking, and internally these routines will call \[vwait\] to get the
    results\. In other words, these routines will return the same value, but
    they'll have event loops running while waiting for Amazon\.

  - __\-parse\-xml__ *xmlstring*

    If provided, the routine skips actually communicating with Amazon, and
    instead behaves as if the XML string provided was returned as the body of
    the call\. Since several of these routines allow the return of data in
    various formats, this argument can be used to parse existing XML to extract
    the bits of information that are needed\. It's also helpful for testing\.

  - __\-bucket__ *bucketname*

    Almost every high\-level command needs to know what bucket the resources are
    in\. This option specifies that\. \(Only the command to list available buckets
    does not require this parameter\.\) This does not need to be URL\-encoded, even
    if it contains special or non\-ASCII characters\. May or may not contain
    leading or trailing spaces \- commands normalize the bucket\. If this is not
    supplied, the value is taken from __S3::Configure \-default\-bucket__ if
    that string isn't empty\. Note that spaces and slashes are always trimmed
    from both ends and the rest must leave a valid bucket\.

  - __\-resource__ *resourcename*

    This specifies the resource of interest within the bucket\. It may or may not
    start with a slash \- both cases are handled\. This does not need to be
    URL\-encoded, even if it contains special or non\-ASCII characters\.

  - __\-compare__ *always&#124;never&#124;exists&#124;missing&#124;newer&#124;date&#124;checksum&#124;different*

    When commands copy resources to files or files to resources, the caller may
    specify that the copy should be skipped if the contents are the same\. This
    argument specifies the conditions under which the files should be copied\. If
    it is not passed, the result of __S3::Configure \-default\-compare__ is
    used, which in turn defaults to "always\." The meanings of the various values
    are these:

      * *always*

        Always copy the data\. This is the default\.

      * *never*

        Never copy the data\. This is essentially a no\-op, except in
        __S3::Push__ and __S3::Pull__ where the \-delete flag might make
        a difference\.

      * *exists*

        Copy the data only if the destination already exists\.

      * *missing*

        Copy the data only if the destination does not already exist\.

      * *newer*

        Copy the data if the destination is missing, or if the date on the
        source is newer than the date on the destination by at least
        __S3::Configure \-slop\-seconds__ seconds\. If the source is Amazon,
        the date is taken from the Last\-Modified header\. If the source is local,
        it is taken as the mtime of the file\. If the source data is specified in
        a string rather than a file, it is taken as right now, via \[clock
        seconds\]\.

      * *date*

        Like *newer*, except copy if the date is newer *or* older\.

      * *checksum*

        Calculate the MD5 checksum on the local file or string, ask Amazon for
        the eTag of the resource, and copy the data if they're different\. Copy
        the data also if the destination is missing\. Note that this can be slow
        with large local files unless the C version of the MD5 support is
        available\.

      * *different*

        Copy the data if the destination does not exist\. If the destination
        exists and an actual file name was specified \(rather than a content
        string\), and the date on the file differs from the date on the resource,
        copy the data\. If the data is provided as a content string, the "date"
        is treated as "right now", so it will likely always differ unless
        slop\-seconds is large\. If the dates are the same, the MD5 checksums are
        compared, and the data is copied if the checksums differ\.

    Note that "newer" and "date" don't care about the contents, and "checksum"
    doesn't care about the dates, but "different" checks both\.

  - <a name='4'></a>__S3::ListAllMyBuckets__ ?__\-blocking__ *boolean*? ?__\-parse\-xml__ *xmlstring*? ?__\-result\-type__ *REST&#124;xml&#124;pxml&#124;dict&#124;names&#124;owner*?

    This routine performs a GET on the Amazon S3 service, which is defined to
    return a list of buckets owned by the account identified by the
    authorization header\. \(Blame Amazon for the dumb names\.\)

      * __\-blocking__ *boolean*

        See above for standard definition\.

      * __\-parse\-xml__ *xmlstring*

        See above for standard definition\.

      * __\-result\-type__ *REST*

        The dictionary returned by __S3::REST__ is the return value of
        __S3::ListAllMyBuckets__\. In this case, a non\-2XX httpstatus will
        not throw an error\. You may not combine this with *\-parse\-xml*\.

      * __\-result\-type__ *xml*

        The raw XML of the body is returned as the result \(with no encoding
        applied\)\.

      * __\-result\-type__ *pxml*

        The XML of the body as parsed by __xsxp::parse__ is returned\.

      * __\-result\-type__ *dict*

        A dictionary of interesting portions of the XML is returned\. The
        dictionary contains the following keys:

          + Owner/ID

            The Amazon AWS ID \(in hex\) of the owner of the bucket\.

          + Owner/DisplayName

            The Amazon AWS ID's Display Name\.

          + Bucket/Name

            A list of names, one for each bucket\.

          + Bucket/CreationDate

            A list of dates, one for each bucket, in the same order as
            Bucket/Name, in ISO format \(as returned by Amazon\)\.

      * __\-result\-type__ *names*

        A list of bucket names is returned with all other information stripped
        out\. This is the default result type for this command\.

      * __\-result\-type__ *owner*

        A list containing two elements is returned\. The first element is the
        owner's ID, and the second is the owner's display name\.

  - <a name='5'></a>__S3::PutBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*? ?__\-acl__ *\{\}&#124;private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read*?

    This command creates a bucket if it does not already exist\. Bucket names are
    globally unique, so you may get a "Forbidden" error from Amazon even if you
    cannot see the bucket in __S3::ListAllMyBuckets__\. See
    __S3::SuggestBucket__ for ways to minimize this risk\. The x\-amz\-acl
    header comes from the __\-acl__ option, or from __S3::Configure
    \-default\-acl__ if not specified\.

  - <a name='6'></a>__S3::DeleteBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*?

    This command deletes a bucket if it is empty and you have such permission\.
    Note that Amazon's list of buckets is a global resource, requiring far\-flung
    synchronization\. If you delete a bucket, it may be quite a few minutes \(or
    hours\) before you can recreate it, yielding "Conflict" errors until then\.

  - <a name='7'></a>__S3::GetBucket__ ?__\-bucket__ *bucketname*? ?__\-blocking__ *boolean*? ?__\-parse\-xml__ *xmlstring*? ?__\-max\-count__ *integer*? ?__\-prefix__ *prefixstring*? ?__\-delimiter__ *delimiterstring*? ?__\-result\-type__ *REST&#124;xml&#124;pxml&#124;names&#124;dict*?

    This lists the contents of a bucket\. That is, it returns a directory listing
    of resources within a bucket, rather than transfering any user data\.

      * __\-bucket__ *bucketname*

        The standard bucket argument\.

      * __\-blocking__ *boolean*

        The standard blocking argument\.

      * __\-parse\-xml__ *xmlstring*

        The standard parse\-xml argument\.

      * __\-max\-count__ *integer*

        If supplied, this is the most number of records to be returned\. If not
        supplied, the code will iterate until all records have been found\. Not
        compatible with \-parse\-xml\. Note that if this is supplied, only one call
        to __S3::REST__ will be made\. Otherwise, enough calls will be made
        to exhaust the listing, buffering results in memory, so take care if you
        may have huge buckets\.

      * __\-prefix__ *prefixstring*

        If present, restricts listing to resources with a particular prefix\. One
        leading / is stripped if present\.

      * __\-delimiter__ *delimiterstring*

        If present, specifies a delimiter for the listing\. The presence of this
        will summarize multiple resources into one entry, as if S3 supported
        directories\. See the Amazon documentation for details\.

      * __\-result\-type__ *REST&#124;xml&#124;pxml&#124;names&#124;dict*

        This indicates the format of the return result of the command\.

          + REST

            If *\-max\-count* is specified, the dictionary returned from
            __S3::REST__ is returned\. If *\-max\-count* is not specified, a
            list of all the dictionaries returned from the one or more calls to
            __S3::REST__ is returned\.

          + xml

            If *\-max\-count* is specified, the body returned from
            __S3::REST__ is returned\. If *\-max\-count* is not specified, a
            list of all the bodies returned from the one or more calls to
            __S3::REST__ is returned\.

          + pxml

            If *\-max\-count* is specified, the body returned from
            __S3::REST__ is passed throught __xsxp::parse__ and then
            returned\. If *\-max\-count* is not specified, a list of all the
            bodies returned from the one or more calls to __S3::REST__ are
            each passed through __xsxp::parse__ and then returned\.

          + names

            Returns a list of all names found in either the Contents/Key fields
            or the CommonPrefixes/Prefix fields\. If no *\-delimiter* is
            specified and no *\-max\-count* is specified, this returns a list of
            all resources with the specified *\-prefix*\.

          + dict

            Returns a dictionary\. \(Returns only one dictionary even if
            *\-max\-count* wasn't specified\.\) The keys of the dictionary are as
            follows:

              - Name

                The name of the bucket \(from the final call to
                __S3::REST__\)\.

              - Prefix

                From the final call to __S3::REST__\.

              - Marker

                From the final call to __S3::REST__\.

              - MaxKeys

                From the final call to __S3::REST__\.

              - IsTruncated

                From the final call to __S3::REST__, so always false if
                *\-max\-count* is not specified\.

              - NextMarker

                Always provided if IsTruncated is true, and calculated of Amazon
                does not provide it\. May be empty if IsTruncated is false\.

              - Key

                A list of names of resources in the bucket matching the
                *\-prefix* and *\-delimiter* restrictions\.

              - LastModified

                A list of times of resources in the bucket, in the same order as
                Key, in the format returned by Amazon\. \(I\.e\., it is not parsed
                into a seconds\-from\-epoch\.\)

              - ETag

                A list of entity tags \(a\.k\.a\. MD5 checksums\) in the same order
                as Key\.

              - Size

                A list of sizes in bytes of the resources, in the same order as
                Key\.

              - Owner/ID

                A list of owners of the resources in the bucket, in the same
                order as Key\.

              - Owner/DisplayName

                A list of owners of the resources in the bucket, in the same
                order as Key\. These are the display names\.

              - CommonPrefixes/Prefix

                A list of prefixes common to multiple entities\. This is present
                only if *\-delimiter* was supplied\.

  - <a name='8'></a>__S3::Put__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-file__ *filename*? ?__\-content__ *contentstring*? ?__\-acl__ *private&#124;public\-read&#124;public\-read\-write&#124;authenticated\-read&#124;calc&#124;keep*? ?__\-content\-type__ *contenttypestring*? ?__\-x\-amz\-meta\-\*__ *metadatatext*? ?__\-compare__ *comparemode*?

    This command sends data to a resource on Amazon's servers for storage, using
    the HTTP PUT command\. It returns 0 if the __\-compare__ mode prevented
    the transfer, 1 if the transfer worked, or throws an error if the transfer
    was attempted but failed\. Server 5XX errors and S3 socket errors are retried
    according to __S3:Configure \-retries__ settings before throwing an
    error; other errors throw immediately\.

      * __\-bucket__

        This specifies the bucket into which the resource will be written\.
        Leading and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-blocking__

        The standard blocking flag\.

      * __\-file__

        If this is specified, the *filename* must exist, must be readable, and
        must not be a special or directory file\. \[file size\] must apply to it
        and must not change for the lifetime of the call\. The default
        content\-type is calculated based on the name and/or contents of the
        file\. Specifying this is an error if __\-content__ is also specified,
        but at least one of __\-file__ or __\-content__ must be specified\.
        \(The file is allowed to not exist or not be readable if __\-compare__
        *never* is specified\.\)

      * __\-content__

        If this is specified, the *contentstring* is sent as the body of the
        resource\. The content\-type defaults to "application/octet\-string"\. Only
        the low bytes are sent, so non\-ASCII should use the appropriate encoding
        \(such as \[encoding convertto utf\-8\]\) before passing it to this routine,
        if necessary\. Specifying this is an error if __\-file__ is also
        specified, but at least one of __\-file__ or __\-content__ must be
        specified\.

      * __\-acl__

        This defaults to __S3::Configure \-default\-acl__ if not specified\. It
        sets the x\-amz\-acl header on the PUT operation\. If the value provided is
        *calc*, the x\-amz\-acl header is calculated based on the I/O
        permissions of the file to be uploaded; it is an error to specify
        *calc* and __\-content__\. If the value provided is *keep*, the
        acl of the resource is read before the PUT \(or the default is used if
        the resource does not exist\), then set back to what it was after the PUT
        \(if it existed\)\. An error will occur if the resource is successfully
        written but the kept ACL cannot be then applied\. This should never
        happen\. *Note:* *calc* is not currently fully implemented\.

      * __\-x\-amz\-meta\-\*__

        If any header starts with "\-x\-amz\-meta\-", its contents are added to the
        PUT command to be stored as metadata with the resource\. Again, no
        encoding is performed, and the metadata should not contain characters
        like newlines, carriage returns, and so on\. It is best to stick with
        simple ASCII strings, or to fix the library in several places\.

      * __\-content\-type__

        This overrides the content\-type calculated by __\-file__ or sets the
        content\-type for __\-content__\.

      * __\-compare__

        This is the standard compare mode argument\. __S3::Put__ returns 1 if
        the data was copied or 0 if the data was skipped due to the comparison
        mode so indicating it should be skipped\.

  - <a name='9'></a>__S3::Get__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-compare__ *comparemode*? ?__\-file__ *filename*? ?__\-content__ *contentvarname*? ?__\-timestamp__ *aws&#124;now*? ?__\-headers__ *headervarname*?

    This command retrieves data from a resource on Amazon's S3 servers, using
    the HTTP GET command\. It returns 0 if the __\-compare__ mode prevented
    the transfer, 1 if the transfer worked, or throws an error if the transfer
    was attempted but failed\. Server 5XX errors and S3 socket errors are are
    retried according to __S3:Configure__ settings before throwing an error;
    other errors throw immediately\. Note that this is always authenticated as
    the user configured in via __S3::Configure \-accesskeyid__\. Use the
    Tcllib http for unauthenticated GETs\.

      * __\-bucket__

        This specifies the bucket from which the resource will be read\. Leading
        and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-blocking__

        The standard blocking flag\.

      * __\-file__

        If this is specified, the body of the resource will be read into this
        file, incrementally without pulling it entirely into memory first\. The
        parent directory must already exist\. If the file already exists, it must
        be writable\. If an error is thrown part\-way through the process and the
        file already existed, it may be clobbered\. If an error is thrown
        part\-way through the process and the file did not already exist, any
        partial bits will be deleted\. Specifying this is an error if
        __\-content__ is also specified, but at least one of __\-file__ or
        __\-content__ must be specified\.

      * __\-timestamp__

        This is only valid in conjunction with __\-file__\. It may be
        specified as *now* or *aws*\. The default is *now*\. If *now*, the
        file's modification date is left up to the system\. If *aws*, the
        file's mtime is set to match the Last\-Modified header on the resource,
        synchronizing the two appropriately for __\-compare__ *date* or
        __\-compare__ *newer*\.

      * __\-content__

        If this is specified, the *contentvarname* is a variable in the
        caller's scope \(not necessarily global\) that receives the value of the
        body of the resource\. No encoding is done, so if the resource \(for
        example\) represents a UTF\-8 byte sequence, use \[encoding convertfrom
        utf\-8\] to get a valid UTF\-8 string\. If this is specified, the
        __\-compare__ is ignored unless it is *never*, in which case no
        assignment to *contentvarname* is performed\. Specifying this is an
        error if __\-file__ is also specified, but at least one of
        __\-file__ or __\-content__ must be specified\.

      * __\-compare__

        This is the standard compare mode argument\. __S3::Get__ returns 1 if
        the data was copied or 0 if the data was skipped due to the comparison
        mode so indicating it should be skipped\.

      * __\-headers__

        If this is specified, the headers resulting from the fetch are stored in
        the provided variable, as a dictionary\. This will include content\-type
        and x\-amz\-meta\-\* headers, as well as the usual HTTP headers, the
        x\-amz\-id debugging headers, and so on\. If no file is fetched \(due to
        __\-compare__ or other errors\), no assignment to this variable is
        performed\.

  - <a name='10'></a>__S3::Head__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-dict__ *dictvarname*? ?__\-headers__ *headersvarname*? ?__\-status__ *statusvarname*?

    This command requests HEAD from the resource\. It returns whether a 2XX code
    was returned as a result of the request, never throwing an S3 remote error\.
    That is, if this returns 1, the resource exists and is accessible\. If this
    returns 0, something went wrong, and the __\-status__ result can be
    consulted for details\.

      * __\-bucket__

        This specifies the bucket from which the resource will be read\. Leading
        and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-blocking__

        The standard blocking flag\.

      * __\-dict__

        If specified, the resulting dictionary from the __S3::REST__ call is
        assigned to the indicated \(not necessarily global\) variable in the
        caller's scope\.

      * __\-headers__

        If specified, the dictionary of headers from the result are assigned to
        the indicated \(not necessarily global\) variable in the caller's scope\.

      * __\-status__

        If specified, the indicated \(not necessarily global\) variable in the
        caller's scope is assigned a 2\-element list\. The first element is the
        3\-digit HTTP status code, while the second element is the HTTP message
        \(such as "OK" or "Forbidden"\)\.

  - <a name='11'></a>__S3::GetAcl__ ?__\-blocking__ *boolean*? ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-result\-type__ *REST&#124;xml&#124;pxml*?

    This command gets the ACL of the indicated resource or throws an error if it
    is unavailable\.

      * __\-blocking__ *boolean*

        See above for standard definition\.

      * __\-bucket__

        This specifies the bucket from which the resource will be read\. Leading
        and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-parse\-xml__ *xml*

        The XML from a previous GetACL can be passed in to be parsed into
        dictionary form\. In this case, \-result\-type must be pxml or dict\.

      * __\-result\-type__ *REST*

        The dictionary returned by __S3::REST__ is the return value of
        __S3::GetAcl__\. In this case, a non\-2XX httpstatus will not throw an
        error\.

      * __\-result\-type__ *xml*

        The raw XML of the body is returned as the result \(with no encoding
        applied\)\.

      * __\-result\-type__ *pxml*

        The XML of the body as parsed by __xsxp::parse__ is returned\.

      * __\-result\-type__ *dict*

        This fetches the ACL, parses it, and returns a dictionary of two
        elements\.

        The first element has the key "owner" whose value is the canonical ID of
        the owner of the resource\.

        The second element has the key "acl" whose value is a dictionary\. Each
        key in the dictionary is one of Amazon's permissions, namely "READ",
        "WRITE", "READ\_ACP", "WRITE\_ACP", or "FULL\_CONTROL"\. Each value of each
        key is a list of canonical IDs or group URLs that have that permission\.
        Elements are not in the list in any particular order, and not all keys
        are necessarily present\. Display names are not returned, as they are not
        especially useful; use pxml to obtain them if necessary\.

  - <a name='12'></a>__S3::PutAcl__ ?__\-blocking__ *boolean*? ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-acl__ *new\-acl*?

    This sets the ACL on the indicated resource\. It returns the XML written to
    the ACL, or throws an error if anything went wrong\.

      * __\-blocking__ *boolean*

        See above for standard definition\.

      * __\-bucket__

        This specifies the bucket from which the resource will be read\. Leading
        and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-owner__

        If this is provided, it is assumed to match the owner of the resource\.
        Otherwise, a GET may need to be issued against the resource to find the
        owner\. If you already have the owner \(such as from a call to
        __S3::GetAcl__, you can pass the value of the "owner" key as the
        value of this option, and it will be used in the construction of the
        XML\.

      * __\-acl__

        If this option is specified, it provides the ACL the caller wishes to
        write to the resource\. If this is not supplied or is empty, the value is
        taken from __S3::Configure \-default\-acl__\. The ACL is written with a
        PUT to the ?acl resource\.

        If the value passed to this option starts with "<", it is taken to be a
        body to be PUT to the ACL resource\.

        If the value matches one of the standard Amazon x\-amz\-acl headers \(i\.e\.,
        a canned access policy\), that header is translated to XML and then
        applied\. The canned access policies are private, public\-read,
        public\-read\-write, and authenticated\-read \(in lower case\)\.

        Otherwise, the value is assumed to be a dictionary formatted as the
        "acl" sub\-entry within the dict returns by __S3::GetAcl \-result\-type
        dict__\. The proper XML is generated and applied to the resource\. Note
        that a value containing "//" is assumed to be a group, a value
        containing "@" is assumed to be an AmazonCustomerByEmail, and otherwise
        the value is assumed to be a canonical Amazon ID\.

        Note that you cannot change the owner, so calling GetAcl on a resource
        owned by one user and applying it via PutAcl on a resource owned by
        another user may not do exactly what you expect\.

  - <a name='13'></a>__S3::Delete__ ?__\-bucket__ *bucketname*? __\-resource__ *resourcename* ?__\-blocking__ *boolean*? ?__\-status__ *statusvar*?

    This command deletes the specified resource from the specified bucket\. It
    returns 1 if the resource was deleted successfully, 0 otherwise\. It returns
    0 rather than throwing an S3 remote error\.

      * __\-bucket__

        This specifies the bucket from which the resource will be deleted\.
        Leading and/or trailing slashes are removed for you, as are spaces\.

      * __\-resource__

        This is the full name of the resource within the bucket\. A single
        leading slash is removed, but not a trailing slash\. Spaces are not
        trimmed\.

      * __\-blocking__

        The standard blocking flag\.

      * __\-status__

        If specified, the indicated \(not necessarily global\) variable in the
        caller's scope is set to a two\-element list\. The first element is the
        3\-digit HTTP status code\. The second element is the HTTP message \(such
        as "OK" or "Forbidden"\)\. Note that Amazon's DELETE result is 204 on
        success, that being the code indicating no content in the returned body\.

  - <a name='14'></a>__S3::Push__ ?__\-bucket__ *bucketname*? __\-directory__ *directoryname* ?__\-prefix__ *prefixstring*? ?__\-compare__ *comparemode*? ?__\-x\-amz\-meta\-\*__ *metastring*? ?__\-acl__ *aclcode*? ?__\-delete__ *boolean*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?

    This synchronises a local directory with a remote bucket by pushing the
    differences using __S3::Put__\. Note that if something has changed in the
    bucket but not locally, those changes could be lost\. Thus, this is not a
    general two\-way synchronization primitive\. \(See __S3::Sync__ for that\.\)
    Note too that resource names are case sensitive, so changing the case of a
    file on a Windows machine may lead to otherwise\-unnecessary transfers\. Note
    that only regular files are considered, so devices, pipes, symlinks, and
    directories are not copied\.

      * __\-bucket__

        This names the bucket into which data will be pushed\.

      * __\-directory__

        This names the local directory from which files will be taken\. It must
        exist, be readable via \[glob\] and so on\. If only some of the files
        therein are readable, __S3::Push__ will PUT those files that are
        readable and return in its results the list of files that could not be
        opened\.

      * __\-prefix__

        This names the prefix that will be added to all resources\. That is, it
        is the remote equivalent of __\-directory__\. If it is not specified,
        the root of the bucket will be treated as the remote directory\. An
        example may clarify\.

            S3::Push -bucket test -directory /tmp/xyz -prefix hello/world

        In this example, /tmp/xyz/pdq\.html will be stored as
        http://s3\.amazonaws\.com/test/hello/world/pdq\.html in Amazon's servers\.
        Also, /tmp/xyz/abc/def/Hello will be stored as
        http://s3\.amazonaws\.com/test/hello/world/abc/def/Hello in Amazon's
        servers\. Without the __\-prefix__ option, /tmp/xyz/pdq\.html would be
        stored as http://s3\.amazonaws\.com/test/pdq\.html\.

      * __\-blocking__

        This is the standard blocking option\.

      * __\-compare__

        If present, this is passed to each invocation of __S3::Put__\.
        Naturally, __S3::Configure \-default\-compare__ is used if this is not
        specified\.

      * __\-x\-amz\-meta\-\*__

        If present, this is passed to each invocation of __S3::Put__\. All
        copied files will have the same metadata\.

      * __\-acl__

        If present, this is passed to each invocation of __S3::Put__\.

      * __\-delete__

        This defaults to false\. If true, resources in the destination that are
        not in the source directory are deleted with __S3::Delete__\. Since
        only regular files are considered, the existance of a symlink, pipe,
        device, or directory in the local source will *not* prevent the
        deletion of a remote resource with a corresponding name\.

      * __\-error__

        This controls the behavior of __S3::Push__ in the event that
        __S3::Put__ throws an error\. Note that errors encountered on the
        local file system or in reading the list of resources in the remote
        bucket always throw errors\. This option allows control over "partial"
        errors, when some files were copied and some were not\.
        __S3::Delete__ is always finished up, with errors simply recorded in
        the return result\.

          + throw

            The error is rethrown with the same errorCode\.

          + break

            Processing stops without throwing an error, the error is recorded in
            the return value, and the command returns with a normal return\. The
            calls to __S3::Delete__ are not started\.

          + continue

            This is the default\. Processing continues without throwing,
            recording the error in the return result, and resuming with the next
            file in the local directory to be copied\.

      * __\-progress__

        If this is specified and the indicated script prefix is not empty, the
        indicated script prefix will be invoked several times in the caller's
        context with additional arguments at various points in the processing\.
        This allows progress reporting without backgrounding\. The provided
        prefix will be invoked with additional arguments, with the first
        additional argument indicating what part of the process is being
        reported on\. The prefix is initially invoked with *args* as the first
        additional argument and a dictionary representing the normalized
        arguments to the __S3::Push__ call as the second additional
        argument\. Then the prefix is invoked with *local* as the first
        additional argument and a list of suffixes of the files to be considered
        as the second argument\. Then the prefix is invoked with *remote* as
        the first additional argument and a list of suffixes existing in the
        remote bucket as the second additional argument\. Then, for each file in
        the local list, the prefix will be invoked with *start* as the first
        additional argument and the common suffix as the second additional
        argument\. When __S3::Put__ returns for that file, the prefix will be
        invoked with *copy* as the first additional argument, the common
        suffix as the second additional argument, and a third argument that will
        be "copied" \(if __S3::Put__ sent the resource\), "skipped" \(if
        __S3::Put__ decided not to based on __\-compare__\), or the
        errorCode that __S3::Put__ threw due to unexpected errors \(in which
        case the third argument is a list that starts with "S3"\)\. When all files
        have been transfered, the prefix may be invoked zero or more times with
        *delete* as the first additional argument and the suffix of the
        resource being deleted as the second additional argument, with a third
        argument being either an empty string \(if the delete worked\) or the
        errorCode from __S3::Delete__ if it failed\. Finally, the prefix will
        be invoked with *finished* as the first additional argument and the
        return value as the second additional argument\.

    The return result from this command is a dictionary\. They keys are the
    suffixes \(i\.e\., the common portion of the path after the __\-directory__
    and __\-prefix__\), while the values are either "copied", "skipped" \(if
    __\-compare__ indicated not to copy the file\), or the errorCode thrown by
    __S3::Put__, as appropriate\. If __\-delete__ was true, there may also
    be entries for suffixes with the value "deleted" or "notdeleted", indicating
    whether the attempted __S3::Delete__ worked or not, respectively\. There
    is one additional pair in the return result, whose key is the empty string
    and whose value is a nested dictionary\. The keys of this nested dictionary
    include "filescopied" \(the number of files successfully copied\),
    "bytescopied" \(the number of data bytes in the files copied, excluding
    headers, metadata, etc\), "compareskipped" \(the number of files not copied
    due to __\-compare__ mode\), "errorskipped" \(the number of files not
    copied due to thrown errors\), "filesdeleted" \(the number of resources
    deleted due to not having corresponding files locally, or 0 if
    __\-delete__ is false\), and "filesnotdeleted" \(the number of resources
    whose deletion was attempted but failed\)\.

    Note that this is currently implemented somewhat inefficiently\. It fetches
    the bucket listing \(including timestamps and eTags\), then calls
    __S3::Put__, which uses HEAD to find the timestamps and eTags again\.
    Correcting this with no API change is planned for a future upgrade\.

  - <a name='15'></a>__S3::Pull__ ?__\-bucket__ *bucketname*? __\-directory__ *directoryname* ?__\-prefix__ *prefixstring*? ?__\-blocking__ *boolean*? ?__\-compare__ *comparemode*? ?__\-delete__ *boolean*? ?__\-timestamp__ *aws&#124;now*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?

    This synchronises a remote bucket with a local directory by pulling the
    differences using __S3::Get__ If something has been changed locally but
    not in the bucket, those difference may be lost\. This is not a general
    two\-way synchronization mechanism\. \(See __S3::Sync__ for that\.\) This
    creates directories if needed; new directories are created with default
    permissions\. Note that resource names are case sensitive, so changing the
    case of a file on a Windows machine may lead to otherwise\-unnecessary
    transfers\. Also, try not to store data in resources that end with a slash,
    or which are prefixes of resources that otherwise would start with a slash;
    i\.e\., don't use this if you store data in resources whose names have to be
    directories locally\.

    Note that this is currently implemented somewhat inefficiently\. It fetches
    the bucket listing \(including timestamps and eTags\), then calls
    __S3::Get__, which uses HEAD to find the timestamps and eTags again\.
    Correcting this with no API change is planned for a future upgrade\.

      * __\-bucket__

        This names the bucket from which data will be pulled\.

      * __\-directory__

        This names the local directory into which files will be written It must
        exist, be readable via \[glob\], writable for file creation, and so on\. If
        only some of the files therein are writable, __S3::Pull__ will GET
        those files that are writable and return in its results the list of
        files that could not be opened\.

      * __\-prefix__

        The prefix of resources that will be considered for retrieval\. See
        __S3::Push__ for more details, examples, etc\. \(Of course,
        __S3::Pull__ reads rather than writes, but the prefix is treated
        similarly\.\)

      * __\-blocking__

        This is the standard blocking option\.

      * __\-compare__

        This is passed to each invocation of __S3::Get__ if provided\.
        Naturally, __S3::Configure \-default\-compare__ is used if this is not
        provided\.

      * __\-timestamp__

        This is passed to each invocation of __S3::Get__ if provided\.

      * __\-delete__

        If this is specified and true, files that exist in the
        __\-directory__ that are not in the __\-prefix__ will be deleted
        after all resources have been copied\. In addition, empty directories
        \(other than the top\-level __\-directory__\) will be deleted, as Amazon
        S3 has no concept of an empty directory\.

      * __\-error__

        See __S3::Push__ for a description of this option\.

      * __\-progress__

        See __S3::Push__ for a description of this option\. It differs
        slightly in that local directories may be included with a trailing slash
        to indicate they are directories\.

    The return value from this command is a dictionary\. It is identical in form
    and meaning to the description of the return result of __S3::Push__\. It
    differs only in that directories may be included, with a trailing slash in
    their name, if they are empty and get deleted\.

  - <a name='16'></a>__S3::Toss__ ?__\-bucket__ *bucketname*? __\-prefix__ *prefixstring* ?__\-blocking__ *boolean*? ?__\-error__ *throw&#124;break&#124;continue*? ?__\-progress__ *scriptprefix*?

    This deletes some or all resources within a bucket\. It would be considered a
    "recursive delete" had Amazon implemented actual directories\.

      * __\-bucket__

        The bucket from which resources will be deleted\.

      * ____\-blocking____

        The standard blocking option\.

      * ____\-prefix____

        The prefix for resources to be deleted\. Any resource that starts with
        this string will be deleted\. This is required\. To delete everything in
        the bucket, pass an empty string for the prefix\.

      * ____\-error____

        If this is "throw", __S3::Toss__ rethrows any errors it encounters\.
        If this is "break", __S3::Toss__ returns with a normal return after
        the first error, recording that error in the return result\. If this is
        "continue", which is the default, __S3::Toss__ continues on and
        lists all errors in the return result\.

      * ____\-progress____

        If this is specified and not an empty string, the script prefix will be
        invoked several times in the context of the caller with additional
        arguments appended\. Initially, it will be invoked with the first
        additional argument being *args* and the second being the processed
        list of arguments to __S3::Toss__\. Then it is invoked with
        *remote* as the first additional argument and the list of suffixes in
        the bucket to be deleted as the second additional argument\. Then it is
        invoked with the first additional argument being *delete* and the
        second additional argument being the suffix deleted and the third
        additional argument being "deleted" or "notdeleted" depending on whether
        __S3::Delete__ threw an error\. Finally, the script prefix is invoked
        with a first additional argument of "finished" and a second additional
        argument of the return value\.

    The return value is a dictionary\. The keys are the suffixes of files that
    __S3::Toss__ attempted to delete, and whose values are either the string
    "deleted" or "notdeleted"\. There is also one additional pair, whose key is
    the empty string and whose value is an embedded dictionary\. The keys of this
    embedded dictionary include "filesdeleted" and "filesnotdeleted", each of
    which has integer values\.

# <a name='section6'></a>LIMITATIONS

  - The pure\-Tcl MD5 checking is slow\. If you are processing files in the
    megabyte range, consider ensuring binary support is available\.

  - The commands __S3::Pull__ and __S3::Push__ fetch a directory listing
    which includes timestamps and MD5 hashes, then invoke __S3::Get__ and
    __S3::Put__\. If a complex __\-compare__ mode is specified,
    __S3::Get__ and __S3::Put__ will invoke a HEAD operation for each
    file to fetch timestamps and MD5 hashes of each resource again\. It is
    expected that a future release of this package will solve this without any
    API changes\.

  - The commands __S3::Pull__ and __S3::Push__ fetch a directory listing
    without using __\-max\-count__\. The entire directory is pulled into memory
    at once\. For very large buckets, this could be a performance problem\. The
    author, at this time, does not plan to change this behavior\. Welcome to Open
    Source\.

  - __S3::Sync__ is neither designed nor implemented yet\. The intention
    would be to keep changes synchronised, so changes could be made to both the
    bucket and the local directory and be merged by __S3::Sync__\.

  - Nor is __\-compare__ *calc* fully implemented\. This is primarily due to
    Windows not providing a convenient method for distinguishing between local
    files that are "public\-read" or "public\-read\-write"\. Assistance figuring out
    TWAPI for this would be appreciated\. The U\*\*X semantics are difficult to map
    directly as well\. See the source for details\. Note that there are not tests
    for calc, since it isn't done yet\.

  - The HTTP processing is implemented within the library, rather than using a
    "real" HTTP package\. Hence, multi\-line headers are not \(yet\) handled
    correctly\. Do not include carriage returns or linefeeds in x\-amz\-meta\-\*
    headers, content\-type values, and so on\. The author does not at this time
    expect to improve this\.

  - Internally, __S3::Push__ and __S3::Pull__ and __S3::Toss__ are
    all very similar and should be refactored\.

  - The idea of using __\-compare__ *never* __\-delete__ *true* to
    delete files that have been deleted from one place but not the other yet not
    copying changed files is untested\.

# <a name='section7'></a>USAGE SUGGESTIONS

To fetch a "directory" out of a bucket, make changes, and store it back:

    file mkdir ./tempfiles
    S3::Pull -bucket sample -prefix of/interest -directory ./tempfiles \
      -timestamp aws
    do_my_process ./tempfiles other arguments
    S3::Push -bucket sample -prefix of/interest -directory ./tempfiles \
      -compare newer -delete true

To delete files locally that were deleted off of S3 but not otherwise update
files:

    S3::Pull -bucket sample -prefix of/interest -directory ./myfiles \
      -compare never -delete true

# <a name='section8'></a>FUTURE DEVELOPMENTS

The author intends to work on several additional projects related to this
package, in addition to finishing the unfinished features\.

First, a command\-line program allowing browsing of buckets and transfer of files
from shell scripts and command prompts is useful\.

Second, a GUI\-based program allowing visual manipulation of bucket and resource
trees not unlike Windows Explorer would be useful\.

Third, a command\-line \(and perhaps a GUI\-based\) program called "OddJob" that
will use S3 to synchronize computation amongst multiple servers running OddJob\.
An S3 bucket will be set up with a number of scripts to run, and the OddJob
program can be invoked on multiple machines to run scripts on all the machines,
each moving on to the next unstarted task as it finishes each\. This is still
being designed, and it is intended primarily to be run on Amazon's Elastic
Compute Cloud\.

# <a name='section9'></a>TLS Security Considerations

This package uses the __[TLS](\.\./\.\./\.\./\.\./index\.md\#tls)__ package to
handle the security for __https__ urls and other socket connections\.

Policy decisions like the set of protocols to support and what ciphers to use
are not the responsibility of __[TLS](\.\./\.\./\.\./\.\./index\.md\#tls)__, nor
of this package itself however\. Such decisions are the responsibility of
whichever application is using the package, and are likely influenced by the set
of servers the application will talk to as well\.

For example, in light of the recent [POODLE
attack](http://googleonlinesecurity\.blogspot\.co\.uk/2014/10/this\-poodle\-bites\-exploiting\-ssl\-30\.html)
discovered by Google many servers will disable support for the SSLv3 protocol\.
To handle this change the applications using
__[TLS](\.\./\.\./\.\./\.\./index\.md\#tls)__ must be patched, and not this
package, nor __[TLS](\.\./\.\./\.\./\.\./index\.md\#tls)__ itself\. Such a patch
may be as simple as generally activating __tls1__ support, as shown in the
example below\.

    package require tls
    tls::init -tls1 1 ;# forcibly activate support for the TLS1 protocol

    ... your own application code ...

# <a name='section10'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *amazon\-s3* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[amazon](\.\./\.\./\.\./\.\./index\.md\#amazon),
[cloud](\.\./\.\./\.\./\.\./index\.md\#cloud), [s3](\.\./\.\./\.\./\.\./index\.md\#s3)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

2006,2008 Darren New\. All Rights Reserved\. See LICENSE\.TXT for terms\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/modules/amazon-s3/xsxp.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

[//000000001]: # (xsxp \- Amazon S3 Web Service Utilities)
[//000000002]: # (Generated from file 'xsxp\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (2006 Darren New\. All Rights Reserved\.)
[//000000004]: # (xsxp\(n\) 1\.0 tcllib "Amazon S3 Web Service Utilities")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

xsxp \- eXtremely Simple Xml Parser

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [COMMANDS](#section2)

  - [Bugs, Ideas, Feedback](#section3)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require xsxp 1  
package require xml  

[__xsxp::parse__ *xml*](#1)  
[__xsxp::fetch__ *pxml* *path* ?*part*?](#2)  
[__xsxp::fetchall__ *pxml\_list* *path* ?*part*?](#3)  
[__xsxp::only__ *pxml* *tagname*](#4)  
[__xsxp::prettyprint__ *pxml* ?*chan*?](#5)  

# <a name='description'></a>DESCRIPTION

This package provides a simple interface to parse XML into a pure\-value list\. It
also provides accessor routines to pull out specific subtags, not unlike DOM
access\. This package was written for and is used by Darren New's Amazon S3
access package\.

This is pretty lame, but I needed something like this for S3, and at the time,
TclDOM would not work with the new 8\.5 Tcl due to version number problems\.

In addition, this is a pure\-value implementation\. There is no garbage to clean
up in the event of a thrown error, for example\. This simplifies the code for
sufficiently small XML documents, which is what Amazon's S3 guarantees\.

Copyright 2006 Darren New\. All Rights Reserved\. NO WARRANTIES OF ANY TYPE ARE
PROVIDED\. COPYING OR USE INDEMNIFIES THE AUTHOR IN ALL WAYS\. This software is
licensed under essentially the same terms as Tcl\. See LICENSE\.txt for the terms\.

# <a name='section2'></a>COMMANDS

The package implements five rather simple procedures\. One parses, one is for
debugging, and the rest pull various parts of the parsed document out for
processing\.

  - <a name='1'></a>__xsxp::parse__ *xml*

    This parses an XML document \(using the standard xml tcllib module in a SAX
    sort of way\) and builds a data structure which it returns if the parsing
    succeeded\. The return value is referred to herein as a "pxml", or "parsed
    xml"\. The list consists of two or more elements:

      * The first element is the name of the tag\.

      * The second element is an array\-get formatted list of key/value pairs\.
        The keys are attribute names and the values are attribute values\. This
        is an empty list if there are no attributes on the tag\.

      * The third through end elements are the children of the node, if any\.
        Each child is, recursively, a pxml\.

      * Note that if the zero'th element, i\.e\. the tag name, is "%PCDATA", then
        the attributes will be empty and the third element will be the text of
        the element\. In addition, if an element's contents consists only of
        PCDATA, it will have only one child, and all the PCDATA will be
        concatenated\. In other words, this parser works poorly for XML with
        elements that contain both child tags and PCDATA\. Since Amazon S3 does
        not do this \(and for that matter most uses of XML where XML is a poor
        choice don't do this\), this is probably not a serious limitation\.

  - <a name='2'></a>__xsxp::fetch__ *pxml* *path* ?*part*?

    *pxml* is a parsed XML, as returned from xsxp::parse\. *path* is a list
    of element tag names\. Each element is the name of a child to look up,
    optionally followed by a hash \("\#"\) and a string of digits\. An empty list or
    an initial empty element selects *pxml*\. If no hash sign is present, the
    behavior is as if "\#0" had been appended to that element\. \(In addition to a
    list, slashes can separate subparts where convenient\.\)

    An element of *path* scans the children at the indicated level for the
    n'th instance of a child whose tag matches the part of the element before
    the hash sign\. If an element is simply "\#" followed by digits, that indexed
    child is selected, regardless of the tags in the children\. Hence, an element
    of "\#3" will always select the fourth child of the node under consideration\.

    *part* defaults to "%ALL"\. It can be one of the following case\-sensitive
    terms:

      * %ALL

        returns the entire selected element\.

      * %TAGNAME

        returns lindex 0 of the selected element\.

      * %ATTRIBUTES

        returns index 1 of the selected element\.

      * %CHILDREN

        returns lrange 2 through end of the selected element, resulting in a
        list of elements being returned\.

      * %PCDATA

        returns a concatenation of all the bodies of direct children of this
        node whose tag is %PCDATA\. It throws an error if no such children are
        found\. That is, part=%PCDATA means return the textual content found in
        that node but not its children nodes\.

      * %PCDATA?

        is like %PCDATA, but returns an empty string if no PCDATA is found\.

    For example, to fetch the first bold text from the fifth paragraph of the
    body of your HTML file,

        xsxp::fetch $pxml {body p#4 b} %PCDATA

  - <a name='3'></a>__xsxp::fetchall__ *pxml\_list* *path* ?*part*?

    This iterates over each PXML in *pxml\_list* \(which must be a list of
    pxmls\) selecting the indicated path from it, building a new list with the
    selected data, and returning that new list\.

    For example, *pxml\_list* might be the %CHILDREN of a particular element,
    and the *path* and *part* might select from each child a sub\-element in
    which we're interested\.

  - <a name='4'></a>__xsxp::only__ *pxml* *tagname*

    This iterates over the direct children of *pxml* and selects only those
    with *tagname* as their tag\. Returns a list of matching elements\.

  - <a name='5'></a>__xsxp::prettyprint__ *pxml* ?*chan*?

    This outputs to *chan* \(default stdout\) a pretty\-printed version of
    *pxml*\.

# <a name='section3'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *amazon\-s3* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[dom](\.\./\.\./\.\./\.\./index\.md\#dom), [parser](\.\./\.\./\.\./\.\./index\.md\#parser),
[xml](\.\./\.\./\.\./\.\./index\.md\#xml)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

2006 Darren New\. All Rights Reserved\.
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




































































































































































































































































































































































































Deleted embedded/md/tcllib/files/modules/asn/asn.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517

[//000000001]: # (asn \- ASN\.1 processing)
[//000000002]: # (Generated from file 'asn\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2004 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (Copyright &copy; 2004 Jochen Loewer <loewerj@web\.de>)
[//000000005]: # (Copyright &copy; 2004\-2011 Michael Schlenker <mic42@users\.sourceforge\.net>)
[//000000006]: # (asn\(n\) 0\.8 tcllib "ASN\.1 processing")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

asn \- ASN\.1 BER encoder/decoder

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [PUBLIC API](#section2)

      - [ENCODER](#subsection1)

      - [DECODER](#subsection2)

      - [HANDLING TAGS](#subsection3)

  - [EXAMPLES](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require asn ?0\.8\.4?  

[__::asn::asnSequence__ *evalue*\.\.\.](#1)  
[__::asn::asnSequenceFromList__ *elist*](#2)  
[__::asn::asnSet__ *evalue*\.\.\.](#3)  
[__::asn::asnSetFromList__ *elist*](#4)  
[__::asn::asnApplicationConstr__ *appNumber* *evalue*\.\.\.](#5)  
[__::asn::asnApplication__ *appNumber* *data*](#6)  
[__::asn::asnChoice__ *appNumber* *evalue*\.\.\.](#7)  
[__::asn::asnChoiceConstr__ *appNumber* *evalue*\.\.\.](#8)  
[__::asn::asnInteger__ *number*](#9)  
[__::asn::asnEnumeration__ *number*](#10)  
[__::asn::asnBoolean__ *bool*](#11)  
[__::asn::asnContext__ *context* *data*](#12)  
[__::asn::asnContextConstr__ *context* *evalue*\.\.\.](#13)  
[__::asn::asnObjectIdentifier__ *idlist*](#14)  
[__::asn::asnUTCTime__ *utcstring*](#15)  
[__::asn::asnNull__](#16)  
[__::asn::asnBitString__ *string*](#17)  
[__::asn::asnOctetString__ *string*](#18)  
[__::asn::asnNumericString__ *string*](#19)  
[__::asn::asnPrintableString__ *string*](#20)  
[__::asn::asnIA5String__ *string*](#21)  
[__::asn::asnBMPString__ *string*](#22)  
[__::asn::asnUTF8String__ *string*](#23)  
[__::asn::asnString__ *string*](#24)  
[__::asn::defaultStringType__ ?*type*?](#25)  
[__::asn::asnPeekByte__ *data\_var* *byte\_var*](#26)  
[__::asn::asnGetLength__ *data\_var* *length\_var*](#27)  
[__::asn::asnGetResponse__ *chan* *data\_var*](#28)  
[__::asn::asnGetInteger__ *data\_var* *int\_var*](#29)  
[__::asn::asnGetEnumeration__ *data\_var* *enum\_var*](#30)  
[__::asn::asnGetOctetString__ *data\_var* *string\_var*](#31)  
[__::asn::asnGetString__ *data\_var* *string\_var* ?*type\_var*?](#32)  
[__::asn::asnGetNumericString__ *data\_var* *string\_var*](#33)  
[__::asn::asnGetPrintableString__ *data\_var* *string\_var*](#34)  
[__::asn::asnGetIA5String__ *data\_var* *string\_var*](#35)  
[__::asn::asnGetBMPString__ *data\_var* *string\_var*](#36)  
[__::asn::asnGetUTF8String__ *data\_var* *string\_var*](#37)  
[__::asn::asnGetUTCTime__ *data\_var* *utc\_var*](#38)  
[__::asn::asnGetBitString__ *data\_var* *bits\_var*](#39)  
[__::asn::asnGetObjectIdentifier__ *data\_var* *oid\_var*](#40)  
[__::asn::asnGetBoolean__ *data\_var* *bool\_var*](#41)  
[__::asn::asnGetNull__ *data\_var*](#42)  
[__::asn::asnGetSequence__ *data\_var* *sequence\_var*](#43)  
[__::asn::asnGetSet__ *data\_var* *set\_var*](#44)  
[__::asn::asnGetApplication__ *data\_var* *appNumber\_var* ?*content\_var*? ?*encodingType\_var*?](#45)  
[__::asn::asnGetContext__ *data\_var* *contextNumber\_var* ?*content\_var*? ?*encodingType\_var*?](#46)  
[__::asn::asnPeekTag__ *data\_var* *tag\_var* *tagtype\_var* *constr\_var*](#47)  
[__::asn::asnTag__ *tagnumber* ?*class*? ?*tagstyle*?](#48)  
[__::asn::asnRetag__ *data\_var* *newTag*](#49)  

# <a name='description'></a>DESCRIPTION

The __asn__ package provides *partial* de\- and encoder commands for BER
encoded ASN\.1 data\. It can also be used for decoding DER, which is a restricted
subset of BER\.

ASN\.1 is a standard *Abstract Syntax Notation*, and BER are its *Basic
Encoding Rules*\.

See
[http://asn1\.elibel\.tm\.fr/en/standards/index\.htm](http://asn1\.elibel\.tm\.fr/en/standards/index\.htm)
for more information about the standard\.

Also see
[http://luca\.ntop\.org/Teaching/Appunti/asn1\.html](http://luca\.ntop\.org/Teaching/Appunti/asn1\.html)
for *A Layman's Guide to a Subset of ASN\.1, BER, and DER*, an RSA Laboratories
Technical Note by Burton S\. Kaliski Jr\. \(Revised November 1, 1993\)\. A text
version of this note is part of the module sources and should be read by any
implementor\.

# <a name='section2'></a>PUBLIC API

## <a name='subsection1'></a>ENCODER

  - <a name='1'></a>__::asn::asnSequence__ *evalue*\.\.\.

    Takes zero or more encoded values, packs them into an ASN sequence and
    returns its encoded binary form\.

  - <a name='2'></a>__::asn::asnSequenceFromList__ *elist*

    Takes a list of encoded values, packs them into an ASN sequence and returns
    its encoded binary form\.

  - <a name='3'></a>__::asn::asnSet__ *evalue*\.\.\.

    Takes zero or more encoded values, packs them into an ASN set and returns
    its encoded binary form\.

  - <a name='4'></a>__::asn::asnSetFromList__ *elist*

    Takes a list of encoded values, packs them into an ASN set and returns its
    encoded binary form\.

  - <a name='5'></a>__::asn::asnApplicationConstr__ *appNumber* *evalue*\.\.\.

    Takes zero or more encoded values, packs them into an ASN application
    construct and returns its encoded binary form\.

  - <a name='6'></a>__::asn::asnApplication__ *appNumber* *data*

    Takes a single encoded value *data*, packs it into an ASN application
    construct and returns its encoded binary form\.

  - <a name='7'></a>__::asn::asnChoice__ *appNumber* *evalue*\.\.\.

    Takes zero or more encoded values, packs them into an ASN choice construct
    and returns its encoded binary form\.

  - <a name='8'></a>__::asn::asnChoiceConstr__ *appNumber* *evalue*\.\.\.

    Takes zero or more encoded values, packs them into an ASN choice construct
    and returns its encoded binary form\.

  - <a name='9'></a>__::asn::asnInteger__ *number*

    Returns the encoded form of the specified integer *number*\.

  - <a name='10'></a>__::asn::asnEnumeration__ *number*

    Returns the encoded form of the specified enumeration id *number*\.

  - <a name='11'></a>__::asn::asnBoolean__ *bool*

    Returns the encoded form of the specified boolean value *bool*\.

  - <a name='12'></a>__::asn::asnContext__ *context* *data*

    Takes an encoded value and packs it into a constructed value with
    application tag, the *context* number\.

  - <a name='13'></a>__::asn::asnContextConstr__ *context* *evalue*\.\.\.

    Takes zero or more encoded values and packs them into a constructed value
    with application tag, the *context* number\.

  - <a name='14'></a>__::asn::asnObjectIdentifier__ *idlist*

    Takes a list of at least 2 integers describing an object identifier \(OID\)
    value, and returns the encoded value\.

  - <a name='15'></a>__::asn::asnUTCTime__ *utcstring*

    Returns the encoded form of the specified UTC time string\.

  - <a name='16'></a>__::asn::asnNull__

    Returns the NULL encoding\.

  - <a name='17'></a>__::asn::asnBitString__ *string*

    Returns the encoded form of the specified *string*\.

  - <a name='18'></a>__::asn::asnOctetString__ *string*

    Returns the encoded form of the specified *string*\.

  - <a name='19'></a>__::asn::asnNumericString__ *string*

    Returns the *string* encoded as ASN\.1 NumericString\. Raises an error if
    the *string* contains characters other than decimal numbers and space\.

  - <a name='20'></a>__::asn::asnPrintableString__ *string*

    Returns the *string* encoding as ASN\.1 PrintableString\. Raises an error if
    the *string* contains characters which are not allowed by the Printable
    String datatype\. The allowed characters are A\-Z, a\-z, 0\-9, space,
    apostrophe, colon, parentheses, plus, minus, comma, period, forward slash,
    question mark, and the equals sign\.

  - <a name='21'></a>__::asn::asnIA5String__ *string*

    Returns the *string* encoded as ASN\.1 IA5String\. Raises an error if the
    *string* contains any characters outside of the US\-ASCII range\.

  - <a name='22'></a>__::asn::asnBMPString__ *string*

    Returns the *string* encoded as ASN\.1 Basic Multilingual Plane string
    \(Which is essentialy big\-endian UCS2\)\.

  - <a name='23'></a>__::asn::asnUTF8String__ *string*

    Returns the *string* encoded as UTF8 String\. Note that some legacy
    applications such as Windows CryptoAPI do not like UTF8 strings\. Use
    BMPStrings if you are not sure\.

  - <a name='24'></a>__::asn::asnString__ *string*

    Returns an encoded form of *string*, choosing the most restricted ASN\.1
    string type possible\. If the string contains non\-ASCII characters, then
    there is more than one string type which can be used\. See
    __::asn::defaultStringType__\.

  - <a name='25'></a>__::asn::defaultStringType__ ?*type*?

    Selects the string type to use for the encoding of non\-ASCII strings\.
    Returns current default when called without argument\. If the argument
    *type* is supplied, it should be either __UTF8__ or __BMP__ to
    choose UTF8String or BMPString respectively\.

## <a name='subsection2'></a>DECODER

General notes:

  1. Nearly all decoder commands take two arguments\. These arguments are
     variable names, except for __::asn::asnGetResponse__\. The first
     variable contains the encoded ASN value to decode at the beginning, and
     more, and the second variable is where the value is stored to\. The
     remainder of the input after the decoded value is stored back into the
     datavariable\.

  1. After extraction the data variable is always modified first, before by
     writing the extracted value to its variable\. This means that if both
     arguments refer to the same variable, it will always contain the extracted
     value after the call, and not the remainder of the input\.

  - <a name='26'></a>__::asn::asnPeekByte__ *data\_var* *byte\_var*

    Retrieve the first byte of the data, without modifing *data\_var*\. This can
    be used to check for implicit tags\.

  - <a name='27'></a>__::asn::asnGetLength__ *data\_var* *length\_var*

    Decode the length information for a block of BER data\. The tag has already
    to be removed from the data\.

  - <a name='28'></a>__::asn::asnGetResponse__ *chan* *data\_var*

    Reads an encoded ASN *sequence* from the channel *chan* and stores it
    into the variable named by *data\_var*\.

  - <a name='29'></a>__::asn::asnGetInteger__ *data\_var* *int\_var*

    Assumes that an encoded integer value is at the front of the data stored in
    the variable named *data\_var*, extracts and stores it into the variable
    named by *int\_var*\. Additionally removes all bytes associated with the
    value from the data for further processing by the following decoder
    commands\.

  - <a name='30'></a>__::asn::asnGetEnumeration__ *data\_var* *enum\_var*

    Assumes that an enumeration id is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *enum\_var*\. Additionally removes all bytes associated with the value from
    the data for further processing by the following decoder commands\.

  - <a name='31'></a>__::asn::asnGetOctetString__ *data\_var* *string\_var*

    Assumes that a string is at the front of the data stored in the variable
    named *data\_var*, and stores it into the variable named by *string\_var*\.
    Additionally removes all bytes associated with the value from the data for
    further processing by the following decoder commands\.

  - <a name='32'></a>__::asn::asnGetString__ *data\_var* *string\_var* ?*type\_var*?

    Decodes a user\-readable string\. This is a convenience function which is able
    to automatically distinguish all supported ASN\.1 string types and convert
    the input value appropriately\. See __::asn::asnGetPrintableString__,
    __::asnGetIA5String__, etc\. below for the type\-specific conversion
    commands\.

    If the optional third argument *type\_var* is supplied, then the type of
    the incoming string is stored in the variable named by it\.

    The function throws the error "Invalid command name
    asnGetSome__UnsupportedString__" if the unsupported string type
    __Unsupported__ is encountered\. You can create the appropriate function
    "asn::asnGetSome__UnsupportedString__" in your application if
    neccessary\.

  - <a name='33'></a>__::asn::asnGetNumericString__ *data\_var* *string\_var*

    Assumes that a numeric string value is at the front of the data stored in
    the variable named *data\_var*, and stores it into the variable named by
    *string\_var*\. Additionally removes all bytes associated with the value
    from the data for further processing by the following decoder commands\.

  - <a name='34'></a>__::asn::asnGetPrintableString__ *data\_var* *string\_var*

    Assumes that a printable string value is at the front of the data stored in
    the variable named *data\_var*, and stores it into the variable named by
    *string\_var*\. Additionally removes all bytes associated with the value
    from the data for further processing by the following decoder commands\.

  - <a name='35'></a>__::asn::asnGetIA5String__ *data\_var* *string\_var*

    Assumes that a IA5 \(ASCII\) string value is at the front of the data stored
    in the variable named *data\_var*, and stores it into the variable named by
    *string\_var*\. Additionally removes all bytes associated with the value
    from the data for further processing by the following decoder commands\.

  - <a name='36'></a>__::asn::asnGetBMPString__ *data\_var* *string\_var*

    Assumes that a BMP \(two\-byte unicode\) string value is at the front of the
    data stored in the variable named *data\_var*, and stores it into the
    variable named by *string\_var*, converting it into a proper Tcl string\.
    Additionally removes all bytes associated with the value from the data for
    further processing by the following decoder commands\.

  - <a name='37'></a>__::asn::asnGetUTF8String__ *data\_var* *string\_var*

    Assumes that a UTF8 string value is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *string\_var*, converting it into a proper Tcl string\. Additionally removes
    all bytes associated with the value from the data for further processing by
    the following decoder commands\.

  - <a name='38'></a>__::asn::asnGetUTCTime__ *data\_var* *utc\_var*

    Assumes that a UTC time value is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *utc\_var*\. The UTC time value is stored as a string, which has to be
    decoded with the usual clock scan commands\. Additionally removes all bytes
    associated with the value from the data for further processing by the
    following decoder commands\.

  - <a name='39'></a>__::asn::asnGetBitString__ *data\_var* *bits\_var*

    Assumes that a bit string value is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *bits\_var* as a string containing only 0 and 1\. Additionally removes all
    bytes associated with the value from the data for further processing by the
    following decoder commands\.

  - <a name='40'></a>__::asn::asnGetObjectIdentifier__ *data\_var* *oid\_var*

    Assumes that a object identifier \(OID\) value is at the front of the data
    stored in the variable named *data\_var*, and stores it into the variable
    named by *oid\_var* as a list of integers\. Additionally removes all bytes
    associated with the value from the data for further processing by the
    following decoder commands\.

  - <a name='41'></a>__::asn::asnGetBoolean__ *data\_var* *bool\_var*

    Assumes that a boolean value is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *bool\_var*\. Additionally removes all bytes associated with the value from
    the data for further processing by the following decoder commands\.

  - <a name='42'></a>__::asn::asnGetNull__ *data\_var*

    Assumes that a NULL value is at the front of the data stored in the variable
    named *data\_var* and removes the bytes used to encode it from the data\.

  - <a name='43'></a>__::asn::asnGetSequence__ *data\_var* *sequence\_var*

    Assumes that an ASN sequence is at the front of the data stored in the
    variable named *data\_var*, and stores it into the variable named by
    *sequence\_var*\. Additionally removes all bytes associated with the value
    from the data for further processing by the following decoder commands\.

    The data in *sequence\_var* is encoded binary and has to be further decoded
    according to the definition of the sequence, using the decoder commands
    here\.

  - <a name='44'></a>__::asn::asnGetSet__ *data\_var* *set\_var*

    Assumes that an ASN set is at the front of the data stored in the variable
    named *data\_var*, and stores it into the variable named by *set\_var*\.
    Additionally removes all bytes associated with the value from the data for
    further processing by the following decoder commands\.

    The data in *set\_var* is encoded binary and has to be further decoded
    according to the definition of the set, using the decoder commands here\.

  - <a name='45'></a>__::asn::asnGetApplication__ *data\_var* *appNumber\_var* ?*content\_var*? ?*encodingType\_var*?

    Assumes that an ASN application construct is at the front of the data stored
    in the variable named *data\_var*, and stores its id into the variable
    named by *appNumber\_var*\. Additionally removes all bytes associated with
    the value from the data for further processing by the following decoder
    commands\. If a *content\_var* is specified, then the command places all
    data associated with it into the named variable, in the binary form which
    can be processed using the decoder commands of this package\. If a
    *encodingType\_var* is specified, then that var is set to 1 if the encoding
    is constructed and 0 if it is primitive\.

    Otherwise it is the responsibility of the caller to decode the remainder of
    the application construct based on the id retrieved by this command, using
    the decoder commands of this package\.

  - <a name='46'></a>__::asn::asnGetContext__ *data\_var* *contextNumber\_var* ?*content\_var*? ?*encodingType\_var*?

    Assumes that an ASN context tag construct is at the front of the data stored
    in the variable named *data\_var*, and stores its id into the variable
    named by *contextNumber\_var*\. Additionally removes all bytes associated
    with the value from the data for further processing by the following decoder
    commands\. If a *content\_var* is specified, then the command places all
    data associated with it into the named variable, in the binary form which
    can be processed using the decoder commands of this package\. If a
    *encodingType\_var* is specified, then that var is set to 1 if the encoding
    is constructed and 0 if it is primitive\.

    Otherwise it is the responsibility of the caller to decode the remainder of
    the construct based on the id retrieved by this command, using the decoder
    commands of this package\.

## <a name='subsection3'></a>HANDLING TAGS

Working with ASN\.1 you often need to decode tagged values, which use a tag thats
different from the universal tag for a type\. In those cases you have to replace
the tag with the universal tag used for the type, to decode the value\. To decode
a tagged value use the __::asn::asnRetag__ to change the tag to the
appropriate type to use one of the decoders for primitive values\. To help with
this the module contains three functions:

  - <a name='47'></a>__::asn::asnPeekTag__ *data\_var* *tag\_var* *tagtype\_var* *constr\_var*

    The __::asn::asnPeekTag__ command can be used to take a peek at the data
    and decode the tag value, without removing it from the data\. The *tag\_var*
    gets set to the tag number, while the *tagtype\_var* gets set to the class
    of the tag\. \(Either UNIVERSAL, CONTEXT, APPLICATION or PRIVATE\)\. The
    *constr\_var* is set to 1 if the tag is for a constructed value, and to 0
    for not constructed\. It returns the length of the tag\.

  - <a name='48'></a>__::asn::asnTag__ *tagnumber* ?*class*? ?*tagstyle*?

    The __::asn::asnTag__ can be used to create a tag value\. The
    *tagnumber* gives the number of the tag, while the *class* gives one of
    the classes \(UNIVERSAL,CONTEXT,APPLICATION or PRIVATE\)\. The class may be
    abbreviated to just the first letter \(U,C,A,P\), default is UNIVERSAL\. The
    *tagstyle* is either C for Constructed encoding, or P for primitve
    encoding\. It defaults to P\. You can also use 1 instead of C and 0 instead of
    P for direct use of the values returned by __::asn::asnPeekTag__\.

  - <a name='49'></a>__::asn::asnRetag__ *data\_var* *newTag*

    Replaces the tag in front of the data in *data\_var* with *newTag*\. The
    new Tag can be created using the __::asn::asnTag__ command\.

# <a name='section3'></a>EXAMPLES

Examples for the usage of this package can be found in the implementation of
package __[ldap](\.\./ldap/ldap\.md)__\.

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *asn* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[asn](\.\./\.\./\.\./\.\./index\.md\#asn), [ber](\.\./\.\./\.\./\.\./index\.md\#ber),
[cer](\.\./\.\./\.\./\.\./index\.md\#cer), [der](\.\./\.\./\.\./\.\./index\.md\#der),
[internet](\.\./\.\./\.\./\.\./index\.md\#internet),
[protocol](\.\./\.\./\.\./\.\./index\.md\#protocol),
[x\.208](\.\./\.\./\.\./\.\./index\.md\#x\_208), [x\.209](\.\./\.\./\.\./\.\./index\.md\#x\_209)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2004 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>  
Copyright &copy; 2004 Jochen Loewer <loewerj@web\.de>  
Copyright &copy; 2004\-2011 Michael Schlenker <mic42@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/modules/base32/base32.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

[//000000001]: # (base32 \- Base32 encoding)
[//000000002]: # (Generated from file 'base32\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Public domain)
[//000000004]: # (base32\(n\) 0\.1 tcllib "Base32 encoding")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

base32 \- base32 standard encoding

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [API](#section2)

  - [Code map](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require base32::core ?0\.1?  
package require base32 ?0\.1?  

[__::base32::encode__ *string*](#1)  
[__::base32::decode__ *estring*](#2)  

# <a name='description'></a>DESCRIPTION

This package provides commands for encoding and decoding of strings into and out
of the standard base32 encoding as specified in RFC 3548\.

# <a name='section2'></a>API

  - <a name='1'></a>__::base32::encode__ *string*

    This command encodes the given *string* in base32 and returns the encoded
    string as its result\. The result may be padded with the character __=__
    to signal a partial encoding at the end of the input string\.

  - <a name='2'></a>__::base32::decode__ *estring*

    This commands takes the *estring* and decodes it under the assumption that
    it is a valid base32 encoded string\. The result of the decoding is returned
    as the result of the command\.

    Note that while the encoder will generate only uppercase characters this
    decoder accepts input in lowercase as well\.

    The command will always throw an error whenever encountering conditions
    which signal some type of bogus input, namely if

      1. the input contains characters which are not valid output of a base32
         encoder,

      1. the length of the input is not a multiple of eight,

      1. padding appears not at the end of input, but in the middle,

      1. the padding has not of length six, four, three, or one characters,

# <a name='section3'></a>Code map

The code map used to convert 5\-bit sequences is shown below, with the numeric id
of the bit sequences to the left and the character used to encode it to the
right\. It should be noted that the characters "0" and "1" are not used by the
encoding\. This is done as these characters can be easily confused with "O", "o"
and "l" \(L\)\.

    0 A    9 J   18 S   27 3
    1 B   10 K   19 T   28 4
    2 C   11 L   20 U   29 5
    3 D   12 M   21 V   30 6
    4 E   13 N   22 W   31 7
    5 F   14 O   23 X
    6 G   15 P   24 Y
    7 H   16 Q   25 Z
    8 I   17 R   26 2

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base32* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[base32](\.\./\.\./\.\./\.\./index\.md\#base32),
[rfc3548](\.\./\.\./\.\./\.\./index\.md\#rfc3548)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Public domain
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































































































































































Deleted embedded/md/tcllib/files/modules/base32/base32core.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

[//000000001]: # (base32::core \- Base32 encoding)
[//000000002]: # (Generated from file 'base32core\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Public domain)
[//000000004]: # (base32::core\(n\) 0\.1 tcllib "Base32 encoding")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

base32::core \- Expanding basic base32 maps

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [API](#section2)

  - [Bugs, Ideas, Feedback](#section3)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require base32::core ?0\.1?  

[__::base32::core::define__ *map* *forwvar* *backwvar* *ivar*](#1)  
[__::base32::core::valid__ *string* *pattern* *mvar*](#2)  

# <a name='description'></a>DESCRIPTION

This package provides generic commands for the construction of full base32
mappings from a basic mapping listing just the codes and associated characters\.
The full mappings, regular and inverse, created here map to and from bit
sequences, and also handle the partial mappings at the end of a string\.

This is in essence an internal package to be used by implementors of a base32
en\- and decoder\. A regular user has no need of this package at all\.

# <a name='section2'></a>API

  - <a name='1'></a>__::base32::core::define__ *map* *forwvar* *backwvar* *ivar*

    This command computes full forward and backward \(inverse\) mappings from the
    basic *map* and stores them in the variables named by *forwvar* and
    *backwvar* resp\. It also constructs a regexp pattern for the detection of
    invalid characters in supposedly base32 encoded input and stores it in the
    variable named by *ivar*\.

  - <a name='2'></a>__::base32::core::valid__ *string* *pattern* *mvar*

    This command checks if the input *string* is a valid base32 encoded
    string, based on the *pattern* of invalid characters as generated by
    __::base32::core::define__, and some other general rules\.

    The result of the command is a boolean flag\. Its value is __True__ for a
    valid *string*, and __False__ otherwise\. In the latter case an error
    message describing the problem with the input is stored into the variable
    named by *mvar*\. The variable is not touched if the input was found to be
    valid\.

    The rules checked by the command, beyond rejection of bad characters, are:

      1. The length of the input is not a multiple of eight,

      1. The padding appears not at the end of input, but in the middle,

      1. The padding has not of length six, four, three, or one characters,

# <a name='section3'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base32* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[base32](\.\./\.\./\.\./\.\./index\.md\#base32)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Public domain
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































































































































Deleted embedded/md/tcllib/files/modules/base32/base32hex.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

[//000000001]: # (base32::hex \- Base32 encoding)
[//000000002]: # (Generated from file 'base32hex\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Public domain)
[//000000004]: # (base32::hex\(n\) 0\.1 tcllib "Base32 encoding")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

base32::hex \- base32 extended hex encoding

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [API](#section2)

  - [Code map](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require base32::core ?0\.1?  
package require base32::hex ?0\.1?  

[__::base32::hex::encode__ *string*](#1)  
[__::base32::hex::decode__ *estring*](#2)  

# <a name='description'></a>DESCRIPTION

This package provides commands for encoding and decoding of strings into and out
of the extended hex base32 encoding as specified in the RFC 3548bis draft\.

# <a name='section2'></a>API

  - <a name='1'></a>__::base32::hex::encode__ *string*

    This command encodes the given *string* in extended hex base32 and returns
    the encoded string as its result\. The result may be padded with the
    character __=__ to signal a partial encoding at the end of the input
    string\.

  - <a name='2'></a>__::base32::hex::decode__ *estring*

    This commands takes the *estring* and decodes it under the assumption that
    it is a valid extended hex base32 encoded string\. The result of the decoding
    is returned as the result of the command\.

    Note that while the encoder will generate only uppercase characters this
    decoder accepts input in lowercase as well\.

    The command will always throw an error whenever encountering conditions
    which signal some type of bogus input, namely if

      1. the input contains characters which are not valid output of a extended
         hex base32 encoder,

      1. the length of the input is not a multiple of eight,

      1. padding appears not at the end of input, but in the middle,

      1. the padding has not of length six, four, three, or one characters,

# <a name='section3'></a>Code map

The code map used to convert 5\-bit sequences is shown below, with the numeric id
of the bit sequences to the left and the character used to encode it to the
right\. The important feature of the extended hex mapping is that the first 16
codes map to the digits and hex characters\.

    0 0    9 9        18 I   27 R
    1 1   10 A        19 J   28 S
    2 2   11 B        20 K   29 T
    3 3   12 C        21 L   30 U
    4 4   13 D        22 M   31 V
    5 5   14 E        23 N
    6 6   15 F        24 O
    7 7        16 G   25 P
    8 8        17 H   26 Q

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base32* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[base32](\.\./\.\./\.\./\.\./index\.md\#base32), [hex](\.\./\.\./\.\./\.\./index\.md\#hex),
[rfc3548](\.\./\.\./\.\./\.\./index\.md\#rfc3548)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Public domain
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


























































































































































































































































Deleted embedded/md/tcllib/files/modules/base64/ascii85.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

[//000000001]: # (ascii85 \- Text encoding & decoding binary data)
[//000000002]: # (Generated from file 'ascii85\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2010, Emiliano Gavilán)
[//000000004]: # (ascii85\(n\) 1\.0 tcllib "Text encoding & decoding binary data")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

ascii85 \- ascii85\-encode/decode binary data

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [EXAMPLES](#section2)

  - [References](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require ascii85 ?1\.0?  

[__::ascii85::encode__ ?__\-maxlen__ *maxlen*? ?__\-wrapchar__ *wrapchar*? *string*](#1)  
[__::ascii85::decode__ *string*](#2)  

# <a name='description'></a>DESCRIPTION

This package provides procedures to encode binary data into ascii85 and back\.

  - <a name='1'></a>__::ascii85::encode__ ?__\-maxlen__ *maxlen*? ?__\-wrapchar__ *wrapchar*? *string*

    Ascii85 encodes the given binary *string* and returns the encoded result\.
    Inserts the character *wrapchar* every *maxlen* characters of output\.
    *wrapchar* defaults to newline\. *maxlen* defaults to __76__\.

    *Note well*: If your string is not simple ascii you should fix the string
    encoding before doing ascii85 encoding\. See the examples\.

    The command will throw an error for negative values of *maxlen*, or if
    *maxlen* is not an integer number\.

  - <a name='2'></a>__::ascii85::decode__ *string*

    Ascii85 decodes the given *string* and returns the binary data\. The
    decoder ignores whitespace in the string, as well as tabs and newlines\.

# <a name='section2'></a>EXAMPLES

    % ascii85::encode "Hello, world"
    87cURD_*#TDfTZ)

    % ascii85::encode [string repeat xyz 24]
    G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G
    ^4U[H$X^\H?a^]
    % ascii85::encode -wrapchar "" [string repeat xyz 24]
    G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]G^4U[H$X^\H?a^]

    # NOTE: ascii85 encodes BINARY strings.
    % set chemical [encoding convertto utf-8 "C\u2088H\u2081\u2080N\u2084O\u2082"]
    % set encoded [ascii85::encode $chemical]
    6fN]R8E,5Pidu\UiduhZidua
    % set caffeine [encoding convertfrom utf-8 [ascii85::decode $encoded]]

# <a name='section3'></a>References

  1. [http://en\.wikipedia\.org/wiki/Ascii85](http://en\.wikipedia\.org/wiki/Ascii85)

  1. Postscript Language Reference Manual, 3rd Edition, page 131\.
     [http://www\.adobe\.com/devnet/postscript/pdfs/PLRM\.pdf](http://www\.adobe\.com/devnet/postscript/pdfs/PLRM\.pdf)

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base64* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[ascii85](\.\./\.\./\.\./\.\./index\.md\#ascii85),
[encoding](\.\./\.\./\.\./\.\./index\.md\#encoding)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2010, Emiliano Gavilán
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<










































































































































































































































Deleted embedded/md/tcllib/files/modules/base64/base64.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

[//000000001]: # (base64 \- Text encoding & decoding binary data)
[//000000002]: # (Generated from file 'base64\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2000, Eric Melski)
[//000000004]: # (Copyright &copy; 2001, Miguel Sofer)
[//000000005]: # (base64\(n\) 2\.4\.2 tcllib "Text encoding & decoding binary data")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

base64 \- base64\-encode/decode binary data

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [EXAMPLES](#section2)

  - [Bugs, Ideas, Feedback](#section3)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8  
package require base64 ?2\.4\.2?  

[__::base64::encode__ ?__\-maxlen__ *maxlen*? ?__\-wrapchar__ *wrapchar*? *string*](#1)  
[__::base64::decode__ *string*](#2)  

# <a name='description'></a>DESCRIPTION

This package provides procedures to encode binary data into base64 and back\.

  - <a name='1'></a>__::base64::encode__ ?__\-maxlen__ *maxlen*? ?__\-wrapchar__ *wrapchar*? *string*

    Base64 encodes the given binary *string* and returns the encoded result\.
    Inserts the character *wrapchar* every *maxlen* characters of output\.
    *wrapchar* defaults to newline\. *maxlen* defaults to __76__\.

    *Note* that if *maxlen* is set to __0__, the output will not be
    wrapped at all\.

    *Note well*: If your string is not simple ascii you should fix the string
    encoding before doing base64 encoding\. See the examples\.

    The command will throw an error for negative values of *maxlen*, or if
    *maxlen* is not an integer number\.

  - <a name='2'></a>__::base64::decode__ *string*

    Base64 decodes the given *string* and returns the binary data\. The decoder
    ignores whitespace in the string\.

# <a name='section2'></a>EXAMPLES

    % base64::encode "Hello, world"
    SGVsbG8sIHdvcmxk

    % base64::encode [string repeat xyz 20]
    eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6
    eHl6eHl6eHl6
    % base64::encode -wrapchar "" [string repeat xyz 20]
    eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6eHl6

    # NOTE: base64 encodes BINARY strings.
    % set chemical [encoding convertto utf-8 "C\u2088H\u2081\u2080N\u2084O\u2082"]
    % set encoded [base64::encode $chemical]
    Q+KCiEjigoHigoBO4oKET+KCgg==
    % set caffeine [encoding convertfrom utf-8 [base64::decode $encoded]]

# <a name='section3'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base64* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[base64](\.\./\.\./\.\./\.\./index\.md\#base64),
[encoding](\.\./\.\./\.\./\.\./index\.md\#encoding)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2000, Eric Melski  
Copyright &copy; 2001, Miguel Sofer
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<


































































































































































































































Deleted embedded/md/tcllib/files/modules/base64/uuencode.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

[//000000001]: # (uuencode \- Text encoding & decoding binary data)
[//000000002]: # (Generated from file 'uuencode\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2002, Pat Thoyts)
[//000000004]: # (uuencode\(n\) 1\.1\.4 tcllib "Text encoding & decoding binary data")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

uuencode \- UU\-encode/decode binary data

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [OPTIONS](#section2)

  - [EXAMPLES](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8  
package require uuencode ?1\.1\.4?  

[__::uuencode::encode__ *string*](#1)  
[__::uuencode::decode__ *string*](#2)  
[__::uuencode::uuencode__ ?__\-name__ *string*? ?__\-mode__ *octal*? \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)](#3)  
[__::uuencode::uudecode__ \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)](#4)  

# <a name='description'></a>DESCRIPTION

This package provides a Tcl\-only implementation of the __uuencode\(1\)__ and
__uudecode\(1\)__ commands\. This encoding packs binary data into printable
ASCII characters\.

  - <a name='1'></a>__::uuencode::encode__ *string*

    returns the uuencoded data\. This will encode all the data passed in even if
    this is longer than the uuencode maximum line length\. If the number of input
    bytes is not a multiple of 3 then additional 0 bytes are added to pad the
    string\.

  - <a name='2'></a>__::uuencode::decode__ *string*

    Decodes the given encoded data\. This will return any padding characters as
    well and it is the callers responsibility to deal with handling the actual
    length of the encoded data\. \(see uuencode\)\.

  - <a name='3'></a>__::uuencode::uuencode__ ?__\-name__ *string*? ?__\-mode__ *octal*? \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)

  - <a name='4'></a>__::uuencode::uudecode__ \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)

    UUDecode a file or block of data\. A file may contain more than one embedded
    file so the result is a list where each element is a three element list of
    filename, mode value and data\.

# <a name='section2'></a>OPTIONS

  - \-filename name

    Cause the uuencode or uudecode commands to read their data from the named
    file rather that taking a string parameter\.

  - \-name string

    The uuencoded data header line contains the suggested file name to be used
    when unpacking the data\. Use this option to change this from the default of
    "data\.dat"\.

  - \-mode octal

    The uuencoded data header line contains a suggested permissions bit pattern
    expressed as an octal string\. To change the default of 0644 you can set this
    option\. For instance, 0755 would be suitable for an executable\. See
    __chmod\(1\)__\.

# <a name='section3'></a>EXAMPLES

    % set d [uuencode::encode "Hello World!"]
    2&5L;&\\@5V]R;&0A

    % uuencode::uudecode $d
    Hello World!

    % set d [uuencode::uuencode -name hello.txt "Hello World"]
    begin 644 hello.txt
    +2&5L;&\@5V]R;&0`
    `
    end

    % uuencode::uudecode $d
    {hello.txt 644 {Hello World}}

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base64* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[encoding](\.\./\.\./\.\./\.\./index\.md\#encoding),
[uuencode](\.\./\.\./\.\./\.\./index\.md\#uuencode)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2002, Pat Thoyts
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<




















































































































































































































































































Deleted embedded/md/tcllib/files/modules/base64/yencode.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

[//000000001]: # (yencode \- Text encoding & decoding binary data)
[//000000002]: # (Generated from file 'yencode\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2002, Pat Thoyts)
[//000000004]: # (yencode\(n\) 1\.1\.2 tcllib "Text encoding & decoding binary data")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

yencode \- Y\-encode/decode binary data

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [OPTIONS](#section2)

  - [References](#section3)

  - [Bugs, Ideas, Feedback](#section4)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.2  
package require yencode ?1\.1\.2?  

[__::yencode::encode__ *string*](#1)  
[__::yencode::decode__ *string*](#2)  
[__::yencode::yencode__ ?__\-name__ *string*? ?__\-line__ *integer*? ?__\-crc32__ *boolean*? \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)](#3)  
[__::yencode::ydecode__ \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)](#4)  

# <a name='description'></a>DESCRIPTION

This package provides a Tcl\-only implementation of the yEnc file encoding\. This
is a recently introduced method of encoding binary files for transmission
through Usenet\. This encoding packs binary data into a format that requires an
8\-bit clean transmission layer but that escapes characters special to the
*[NNTP](\.\./\.\./\.\./\.\./index\.md\#nntp)* posting protocols\. See
[http://www\.yenc\.org/](http://www\.yenc\.org/) for details concerning the
algorithm\.

  - <a name='1'></a>__::yencode::encode__ *string*

    returns the yEnc encoded data\.

  - <a name='2'></a>__::yencode::decode__ *string*

    Decodes the given yEnc encoded data\.

  - <a name='3'></a>__::yencode::yencode__ ?__\-name__ *string*? ?__\-line__ *integer*? ?__\-crc32__ *boolean*? \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)

    Encode a file or block of data\.

  - <a name='4'></a>__::yencode::ydecode__ \(__\-file__ *filename* &#124; ?__\-\-__? *string*\)

    Decode a file or block of data\. A file may contain more than one embedded
    file so the result is a list where each element is a three element list of
    filename, file size and data\.

# <a name='section2'></a>OPTIONS

  - \-filename name

    Cause the yencode or ydecode commands to read their data from the named file
    rather that taking a string parameter\.

  - \-name string

    The encoded data header line contains the suggested file name to be used
    when unpacking the data\. Use this option to change this from the default of
    "data\.dat"\.

  - \-line integer

    The yencoded data header line contains records the line length used during
    the encoding\. Use this option to select a line length other that the default
    of 128\. Note that NNTP imposes a 1000 character line length limit and some
    gateways may have trouble with more than 255 characters per line\.

  - \-crc32 boolean

    The yEnc specification recommends the inclusion of a cyclic redundancy check
    value in the footer\. Use this option to change the default from *true* to
    *false*\.

    % set d [yencode::yencode -file testfile.txt]
    =ybegin line=128 size=584 name=testfile.txt
     -o- data not shown -o-
    =yend size=584 crc32=ded29f4f

# <a name='section3'></a>References

  1. [http://www\.yenc\.org/yenc\-draft\.1\.3\.txt](http://www\.yenc\.org/yenc\-draft\.1\.3\.txt)

# <a name='section4'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *base64* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[encoding](\.\./\.\./\.\./\.\./index\.md\#encoding),
[yEnc](\.\./\.\./\.\./\.\./index\.md\#yenc),
[ydecode](\.\./\.\./\.\./\.\./index\.md\#ydecode),
[yencode](\.\./\.\./\.\./\.\./index\.md\#yencode)

# <a name='category'></a>CATEGORY

Text processing

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2002, Pat Thoyts
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<






















































































































































































































































































Deleted embedded/md/tcllib/files/modules/bee/bee.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344

[//000000001]: # (bee \- BitTorrent)
[//000000002]: # (Generated from file 'bee\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2004 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (bee\(n\) 0\.1 tcllib "BitTorrent")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

bee \- BitTorrent Serialization Format Encoder/Decoder

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [PUBLIC API](#section2)

      - [ENCODER](#subsection1)

      - [DECODER](#subsection2)

  - [FORMAT DEFINITION](#section3)

  - [EXAMPLES](#section4)

  - [Bugs, Ideas, Feedback](#section5)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.4  
package require bee ?0\.1?  

[__::bee::encodeString__ *string*](#1)  
[__::bee::encodeNumber__ *integer*](#2)  
[__::bee::encodeListArgs__ *value*\.\.\.](#3)  
[__::bee::encodeList__ *list*](#4)  
[__::bee::encodeDictArgs__ *key* *value*\.\.\.](#5)  
[__::bee::encodeDict__ *dict*](#6)  
[__::bee::decode__ *string* ?*endvar*? ?*start*?](#7)  
[__::bee::decodeIndices__ *string* ?*endvar*? ?*start*?](#8)  
[__::bee::decodeChannel__ *chan* __\-command__ *cmdprefix* ?__\-exact__? ?__\-prefix__ *data*?](#9)  
[__cmdprefix__ __eof__ *token*](#10)  
[__cmdprefix__ __error__ *token* *message*](#11)  
[__cmdprefix__ __value__ *token* *value*](#12)  
[__::bee::decodeCancel__ *token*](#13)  
[__::bee::decodePush__ *token* *string*](#14)  

# <a name='description'></a>DESCRIPTION

The __bee__ package provides de\- and encoder commands for data in bencoding
\(speak 'bee'\), the serialization format for data and messages used by the
BitTorrent protocol\.

# <a name='section2'></a>PUBLIC API

## <a name='subsection1'></a>ENCODER

The package provides one encoder command for each of the basic forms, and two
commands per container, one taking a proper tcl data structure to encode in the
container, the other taking the same information as several arguments\.

  - <a name='1'></a>__::bee::encodeString__ *string*

    Returns the bee\-encoding of the *string*\.

  - <a name='2'></a>__::bee::encodeNumber__ *integer*

    Returns the bee\-encoding of the *integer* number\.

  - <a name='3'></a>__::bee::encodeListArgs__ *value*\.\.\.

    Takes zero or more bee\-encoded values and returns the bee\-encoding of their
    list\.

  - <a name='4'></a>__::bee::encodeList__ *list*

    Takes a list of bee\-encoded values and returns the bee\-encoding of the list\.

  - <a name='5'></a>__::bee::encodeDictArgs__ *key* *value*\.\.\.

    Takes zero or more pairs of keys and values and returns the bee\-encoding of
    the dictionary they form\. The values are expected to be already bee\-encoded,
    but the keys must not be\. Their encoding will be done by the command itself\.

  - <a name='6'></a>__::bee::encodeDict__ *dict*

    Takes a dictionary list of string keys and bee\-encoded values and returns
    the bee\-encoding of the list\. Note that the keys in the input must not be
    bee\-encoded already\. This will be done by the command itself\.

## <a name='subsection2'></a>DECODER

The package provides two main decoder commands, one for decoding a string
expected to contain a complete data structure, the other for the incremental
decoding of bee\-values arriving on a channel\. The latter command is asynchronous
and provides the completed decoded values to the user through a command
callback\.

  - <a name='7'></a>__::bee::decode__ *string* ?*endvar*? ?*start*?

    Takes the bee\-encoding in the string and returns one decoded value\. In the
    case of this being a container all contained values are decoded recursively
    as well and the result is a properly nested tcl list and/or dictionary\.

    If the optional *endvar* is set then it is the name of a variable to store
    the index of the first character *after* the decoded value into\. In other
    words, if the string contains more than one value then *endvar* can be
    used to obtain the position of the bee\-value after the bee\-value currently
    decoded\. together with *start*, see below, it is possible to iterate over
    the string to extract all contained values\.

    The optional *start* index defaults to __0__, i\.e\. the beginning of
    the string\. It is the index of the first character of the bee\-encoded value
    to extract\.

  - <a name='8'></a>__::bee::decodeIndices__ *string* ?*endvar*? ?*start*?

    Takes the same arguments as __::bee::decode__ and returns the same
    information in *endvar*\. The result however is different\. Instead of the
    tcl value contained in the *string* it returns a list describing the value
    with respect to type and location \(indices for the first and last character
    of the bee\-value\)\. In case of a container the structure also contains the
    same information for all the embedded values\.

    Formally the results for the various types of bee\-values are:

      * string

        A list containing three elements:

          + The constant string __string__, denoting the type of the value\.

          + An integer number greater than or equal to zero\. This is the index
            of the first character of the bee\-value in the input *string*\.

          + An integer number greater than or equal to zero\. This is the index
            of the last character of the bee\-value in the input *string*\.

        *Note* that this information is present in the results for all four
        types of bee\-values, with only the first element changing according to
        the type of the value\.

      * integer

        The result is like for strings, except that the type element contains
        the constant string __integer__\.

      * list

        The result is like before, with two exceptions: One, the type element
        contains the constant string __list__\. And two, the result actually
        contains four elements\. The last element is new, and contains the index
        data as described here for all elements of the bee\-list\.

      * dictionary

        The result is like for strings, except that the type element contains
        the constant string __dict__\. A fourth element is present as well,
        with a slightly different structure than for lists\. The element is a
        dictionary mapping from the strings keys of the bee\-dictionary to a list
        containing two elements\. The first of them is the index information for
        the key, and the second element is the index information for the value
        the key maps to\. This structure is the only which contains not only
        index data, but actual values from the bee\-string\. While the index
        information of the keys is unique enough, i\.e\. serviceable as keys, they
        are not easy to navigate when trying to find particular element\. Using
        the actual keys makes this much easier\.

  - <a name='9'></a>__::bee::decodeChannel__ *chan* __\-command__ *cmdprefix* ?__\-exact__? ?__\-prefix__ *data*?

    The command creates a decoder for a series of bee\-values arriving on the
    channel *chan* and returns its handle\. This handle can be used to remove
    the decoder again\. Setting up another bee decoder on *chan* while a bee
    decoder is still active will fail with an error message\.

      * __\-command__

        The command prefix *cmdprefix* specified by the *required* option
        __\-command__ is used to report extracted values and exceptional
        situations \(error, and EOF on the channel\)\. The callback will be
        executed at the global level of the interpreter, with two or three
        arguments\. The exact call signatures are

          + <a name='10'></a>__cmdprefix__ __eof__ *token*

            The decoder has reached eof on the channel *chan*\. No further
            invocations of the callback will be made after this\. The channel has
            already been closed at the time of the call, and the *token* is
            not valid anymore as well\.

          + <a name='11'></a>__cmdprefix__ __error__ *token* *message*

            The decoder encountered an error, which is not eof\. For example a
            malformed bee\-value\. The *message* provides details about the
            error\. The decoder token is in the same state as for eof, i\.e\.
            invalid\. The channel however is kept open\.

          + <a name='12'></a>__cmdprefix__ __value__ *token* *value*

            The decoder received and successfully decoded a bee\-value\. The
            format of the equivalent tcl *value* is the same as returned by
            __::bee::decode__\. The channel is still open and the decoder
            token is valid\. This means that the callback is able to remove the
            decoder\.

      * __\-exact__

        By default the decoder assumes that the remainder of the data in the
        channel consists only of bee\-values, and reads as much as possible per
        event, without regard for boundaries between bee\-values\. This means that
        if the the input contains non\-bee data after a series of bee\-value the
        beginning of that data may be lost because it was already read by the
        decoder, but not processed\.

        The __\-exact__ was made for this situation\. When specified the
        decoder will take care to not read any characters behind the currently
        processed bee\-value, so that any non\-bee data is kept in the channel for
        further processing after removal of the decoder\.

      * __\-prefix__

        If this option is specified its value is assumed to be the beginning of
        the bee\-value and used to initialize the internal decoder buffer\. This
        feature is required if the creator of the decoder used data from the
        channel to determine if it should create the decoder or not\. Without the
        option this data would be lost to the decoding\.

  - <a name='13'></a>__::bee::decodeCancel__ *token*

    This command cancels the decoder set up by __::bee::decodeChannel__ and
    represented by the handle *token*\.

  - <a name='14'></a>__::bee::decodePush__ *token* *string*

    This command appends the *string* to the internal decoder buffer\. It is
    the runtime equivalent of the option __\-prefix__ of
    __::bee::decodeChannel__\. Use it to push data back into the decoder when
    the __value__ callback used data from the channel to determine if it
    should decode another bee\-value or not\.

# <a name='section3'></a>FORMAT DEFINITION

Data in the bee serialization format is constructed from two basic forms, and
two container forms\. The basic forms are strings and integer numbers, and the
containers are lists and dictionaries\.

  - String *S*

    A string *S* of length *L* is encoded by the string
    "*L*__:__*S*", where the length is written out in textual form\.

  - Integer *N*

    An integer number *N* is encoded by the string "__i__*N*__e__"\.

  - List *v1* \.\.\. *vn*

    A list of the values *v1* to *vn* is encoded by the string
    "__l__*BV1*\.\.\.*BVn*__e__" where "BV__i__" is the
    bee\-encoding of the value "v__i__"\.

  - Dict *k1* \-> *v1* \.\.\.

    A dictionary mapping the string key *k*__i__ to the value
    *v*__i__, for __i__ in __1__ \.\.\. __n__ is encoded by the
    string "__d__*BK*__i__*BV*__i__\.\.\.__e__" for i in
    __1__ \.\.\. __n__, where "BK__i__" is the bee\-encoding of the key
    string "k__i__"\. and "BV__i__" is the bee\-encoding of the value
    "v__i__"\.

    *Note*: The bee\-encoding does not retain the order of the keys in the
    input, but stores in a sorted order\. The sorting is done for the "raw
    strings"\.

Note that the type of each encoded item can be determined immediately from the
first character of its representation:

  - i

    Integer\.

  - l

    List\.

  - d

    Dictionary\.

  - \[0\-9\]

    String\.

By wrapping an integer number into __i__\.\.\.__e__ the format makes sure
that they are different from strings, which all begin with a digit\.

# <a name='section4'></a>EXAMPLES

# <a name='section5'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *bee* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='keywords'></a>KEYWORDS

[BitTorrent](\.\./\.\./\.\./\.\./index\.md\#bittorrent),
[bee](\.\./\.\./\.\./\.\./index\.md\#bee),
[bittorrent](\.\./\.\./\.\./\.\./index\.md\#bittorrent),
[serialization](\.\./\.\./\.\./\.\./index\.md\#serialization),
[torrent](\.\./\.\./\.\./\.\./index\.md\#torrent)

# <a name='category'></a>CATEGORY

Networking

# <a name='copyright'></a>COPYRIGHT

Copyright &copy; 2004 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
<
















































































































































































































































































































































































































































































































































































































































































































Deleted embedded/md/tcllib/files/modules/bench/bench.md.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308

[//000000001]: # (bench \- Benchmarking/Performance tools)
[//000000002]: # (Generated from file 'bench\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (Copyright &copy; 2007\-2008 Andreas Kupries <andreas\_kupries@users\.sourceforge\.net>)
[//000000004]: # (bench\(n\) 0\.4 tcllib "Benchmarking/Performance tools")

<hr> [ <a href="../../../../toc.md">Main Table Of Contents</a> &#124; <a
href="../../../toc.md">Table Of Contents</a> &#124; <a
href="../../../../index.md">Keyword Index</a> &#124; <a
href="../../../../toc0.md">Categories</a> &#124; <a
href="../../../../toc1.md">Modules</a> &#124; <a
href="../../../../toc2.md">Applications</a> ] <hr>

# NAME

bench \- bench \- Processing benchmark suites

# <a name='toc'></a>Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [PUBLIC API](#section2)

      - [Benchmark execution](#subsection1)

      - [Result manipulation](#subsection2)

      - [Result format](#subsection3)

  - [Bugs, Ideas, Feedback](#section3)

  - [See Also](#seealso)

  - [Keywords](#keywords)

  - [Category](#category)

  - [Copyright](#copyright)

# <a name='synopsis'></a>SYNOPSIS

package require Tcl 8\.2  
package require bench ?0\.4?  

[__::bench::locate__ *pattern* *paths*](#1)  
[__::bench::run__ ?*option value*\.\.\.? *interp\_list* *file*\.\.\.](#2)  
[__::bench::versions__ *interp\_list*](#3)  
[__::bench::del__ *bench\_result* *column*](#4)  
[__::bench::edit__ *bench\_result* *column* *newvalue*](#5)  
[__::bench::merge__ *bench\_result*\.\.\.](#6)  
[__::bench::norm__ *bench\_result* *column*](#7)  
[__::bench::out::raw__ *bench\_result*](#8)  

# <a name='description'></a>DESCRIPTION

This package provides commands for the execution of benchmarks written in the
bench language, and for the processing of results generated by such execution\.

A reader interested in the bench language itself should start with the *[bench
language introduction](bench\_lang\_intro\.md)* and proceed from there to the
formal *[bench language specification](bench\_lang\_spec\.md)*\.

# <a name='section2'></a>PUBLIC API

## <a name='subsection1'></a>Benchmark execution

  - <a name='1'></a>__::bench::locate__ *pattern* *paths*

    This command locates Tcl interpreters and returns a list containing their
    paths\. It searches them in the list of *paths* specified by the caller,
    using the glob *pattern*\.

    The command resolves soft links to find the actual executables matching the
    pattern\. Note that only interpreters which are marked as executable and are
    actually executable on the current platform are put into the result\.

  - <a name='2'></a>__::bench::run__ ?*option value*\.\.\.? *interp\_list* *file*\.\.\.

    This command executes the benchmarks declared in the set of files, once per
    Tcl interpreter specified via the *interp\_list*, and per the configuration
    specified by the options, and then returns the accumulated timing results\.
    The format of this result is described in section [Result
    format](#subsection3)\.

    It is assumed that the contents of the files are written in the bench
    language\.

    The available options are

      * __\-errors__ *flag*

        The argument is a boolean value\. If set errors in benchmarks are
        propagated to the command, aborting benchmark execution\. Otherwise they
        are recorded in the timing result via a special result code\. The default
        is to propagate and abort\.

      * __\-threads__ *n*

        The argument is a non\-negative integer value declaring the number of
        threads to use while executing the benchmarks\. The default value is
        __0__, to not use threads\.

      * __\-match__ *pattern*

        The argument is a glob pattern\. Only benchmarks whose description
        matches the pattern are executed\. The default is the empty string, to
        execute all patterns\.

      * __\-rmatch__ *pattern*

        The argument is a regular expression pattern\. Only benchmarks whose
        description matches the pattern are executed\. The default is the empty
        string, to execute all patterns\.

      * __\-iters__ *n*

        The argument is positive integer number, the maximal number of
        iterations for any benchmark\. The default is __1000__\. Individual
        benchmarks can override this\.

      * __\-pkgdir__ *path*

        The argument is a path to an existing, readable directory\. Multiple
        paths can be specified, simply use the option multiple times, each time
        with one of the paths to use\.

        If no paths were specified the system will behave as before\. If one or
        more paths are specified, say __N__, each of the specified
        interpreters will be invoked __N__ times, with one of the specified
        paths\. The chosen path is put into the interpreters' __auto\_path__,
        thus allowing it to find specific versions of a package\.

        In this way the use of __\-pkgdir__ allows the user to benchmark
        several different versions of a package, against one or more
        interpreters\.

        *Note:* The empty string is allowed as a path and causes the system to
        run the specified interpreters with an unmodified __auto\_path__\. In
        case the package in question is available there as well\.

  - <a name='3'></a>__::bench::versions__ *interp\_list*

    This command takes a list of Tcl interpreters, identified by their path, and
    returns a dictionary mapping from the interpreters to their versions\.
    Interpreters which are not actually executable, or fail when interrogated,
    are not put into the result\. I\.e the result may contain less interpreters
    than there in the input list\.

    The command uses builtin command __info patchlevel__ to determine the
    version of each interpreter\.

## <a name='subsection2'></a>Result manipulation

  - <a name='4'></a>__::bench::del__ *bench\_result* *column*

    This command removes a column, i\.e\. all benchmark results for a specific Tcl
    interpreter, from the specified benchmark result and returns the modified
    result\.

    The benchmark results are in the format described in section [Result
    format](#subsection3)\.

    The column is identified by an integer number\.

  - <a name='5'></a>__::bench::edit__ *bench\_result* *column* *newvalue*

    This command renames a column in the specified benchmark result and returns
    the modified result\. This means that the path of the Tcl interpreter in the
    identified column is changed to an arbitrary string\.

    The benchmark results are in the format described in section [Result
    format](#subsection3)\.

    The column is identified by an integer number\.

  - <a name='6'></a>__::bench::merge__ *bench\_result*\.\.\.

    This commands takes one or more benchmark results, merges them into one big
    result, and returns that as its result\.

    All benchmark results are in the format described in section [Result
    format](#subsection3)\.

  - <a name='7'></a>__::bench::norm__ *bench\_result* *column*

    This command normalizes the timing results in the specified benchmark result
    and returns the modified result\. This means that the cell values are not
    times anymore, but factors showing how much faster or slower the execution
    was relative to the baseline\.

    The baseline against which the command normalizes are the timing results in
    the chosen column\. This means that after the normalization the values in
    this column are all __1__, as these benchmarks are neither faster nor
    slower than the baseline\.

    A factor less than __1__ indicates a benchmark which was faster than the
    baseline, whereas a factor greater than __1__ indicates a slower
    execution\.

    The benchmark results are in the format described in section [Result
    format](#subsection3)\.

    The column is identified by an integer number\.

  - <a name='8'></a>__::bench::out::raw__ *bench\_result*

    This command formats the specified benchmark result for output to a file,
    socket, etc\. This specific command does no formatting at all, it passes the
    input through unchanged\.

    For other formatting styles see the packages
    __[bench::out::text](bench\_wtext\.md)__ and
    __[bench::out::csv](bench\_wcsv\.md)__ which provide commands to
    format benchmark results for human consumption, or as CSV data importable by
    spread sheets, respectively\.

    Complementary, to read benchmark results from files, sockets etc\. look for
    the package __[bench::in](bench\_read\.md)__ and the commands provided
    by it\.

## <a name='subsection3'></a>Result format

After the execution of a set of benchmarks the raw result returned by this
package is a Tcl dictionary containing all the relevant information\. The
dictionary is a compact representation, i\.e\. serialization, of a 2\-dimensional
table which has Tcl interpreters as columns and benchmarks as rows\. The cells of
the table contain the timing results\. The Tcl interpreters / columns are
identified by their paths\. The benchmarks / rows are identified by their
description\.

The possible keys are all valid Tcl lists of two or three elements and have one
of the following forms:

  - \{interp \*\}

    The set of keys matching this glob pattern capture the information about all
    the Tcl interpreters used to run the benchmarks\. The second element of the
    key is the path to the interpreter\.

    The associated value is the version of the Tcl interpreter\.

  - \{desc \*\}

    The set of keys matching this glob pattern capture the information about all
    the benchmarks found in the executed benchmark suite\. The second element of
    the key is the description of the benchmark, which has to be unique\.

    The associated value is irrelevant, and set to the empty string\.

  - \{usec \* \*\}

    The set of keys matching this glob pattern capture the performance
    information, i\.e\. timing results\. The second element of the key is the
    description of the benchmark, the third element the path of the Tcl
    interpreter which was used to run it\.

    The associated value is either one of several special result codes, or the
    time it took to execute the benchmark, in microseconds\. The possible special
    result codes are

      * ERR

        Benchmark could not be executed, failed with a Tcl error\.

      * BAD\_RES

        The benchmark could be executed, however the result from its body did
        not match the declared expectations\.

# <a name='section3'></a>Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *bench* of the [Tcllib
Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report any ideas
for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# <a name='seealso'></a>SEE ALSO

[bench\_intro](bench\_intro\.md), [bench\_lang\_intro](bench\_lang\_intro\.m