[toc_begin {Table Of Contents} {}]
[division_start {By Categories}]
[division_start {Argument entry form, mega widget}]
[item modules/tepam/tepam_argument_dialogbox.man tepam::argument_dialogbox {TEPAM argument_dialogbox, reference manual}]
[division_end]
[division_start {Benchmark tools}]
[item modules/bench/bench.man            bench            {bench - Processing benchmark suites}]
[item modules/bench/bench_read.man       bench::in        {bench::in - Reading benchmark results}]
[item modules/bench/bench_wcsv.man       bench::out::csv  {bench::out::csv - Formatting benchmark results as CSV}]
[item modules/bench/bench_wtext.man      bench::out::text {bench::out::text - Formatting benchmark results as human readable text}]
[item modules/bench/bench_intro.man      bench_intro      {bench introduction}]
[item modules/bench/bench_lang_intro.man bench_lang_intro {bench language introduction}]
[item modules/bench/bench_lang_spec.man  bench_lang_spec  {bench language specification}]
[division_end]
[division_start {CGI programming}]
[item modules/html/html.man             html        {Procedures to generate HTML structures}]
[item modules/javascript/javascript.man javascript  {Procedures to generate HTML and Java Script structures.}]
[item modules/json/json.man             json        {JSON parser}]
[item modules/json/json_write.man       json::write {JSON generation}]
[item modules/ncgi/ncgi.man             ncgi        {Procedures to manipulate CGI values.}]
[division_end]
[division_start Channels]
[item modules/virtchannel_base/cat.man              tcl::chan::cat            {Concatenation channel}]
[item modules/virtchannel_core/core.man             tcl::chan::core           {Basic reflected/virtual channel support}]
[item modules/virtchannel_core/events.man           tcl::chan::events         {Event support for reflected/virtual channels}]
[item modules/virtchannel_base/facade.man           tcl::chan::facade         {Facade channel}]
[item modules/virtchannel_base/tcllib_fifo.man      tcl::chan::fifo           {In-memory fifo channel}]
[item modules/virtchannel_base/tcllib_fifo2.man     tcl::chan::fifo2          {In-memory interconnected fifo channels}]
[item modules/virtchannel_base/halfpipe.man         tcl::chan::halfpipe       {In-memory channel, half of a fifo2}]
[item modules/virtchannel_base/tcllib_memchan.man   tcl::chan::memchan        {In-memory channel}]
[item modules/virtchannel_base/tcllib_null.man      tcl::chan::null           {Null channel}]
[item modules/virtchannel_base/nullzero.man         tcl::chan::nullzero       {Null/Zero channel combination}]
[item modules/virtchannel_base/tcllib_random.man    tcl::chan::random         {Random channel}]
[item modules/virtchannel_base/std.man              tcl::chan::std            {Standard I/O, unification of stdin and stdout}]
[item modules/virtchannel_base/tcllib_string.man    tcl::chan::string         {Read-only in-memory channel}]
[item modules/virtchannel_base/textwindow.man       tcl::chan::textwindow     {Textwindow channel}]
[item modules/virtchannel_base/tcllib_variable.man  tcl::chan::variable       {In-memory channel using variable for storage}]
[item modules/virtchannel_base/tcllib_zero.man      tcl::chan::zero           {Zero channel}]
[item modules/virtchannel_base/randseed.man         tcl::randomseed           {Utilities for random channels}]
[item modules/virtchannel_transform/adler32.man     tcl::transform::adler32   {Adler32 transformation}]
[item modules/virtchannel_transform/vt_base64.man   tcl::transform::base64    {Base64 encoding transformation}]
[item modules/virtchannel_core/transformcore.man    tcl::transform::core      {Basic reflected/virtual channel transform support}]
[item modules/virtchannel_transform/vt_counter.man  tcl::transform::counter   {Counter transformation}]
[item modules/virtchannel_transform/vt_crc32.man    tcl::transform::crc32     {Crc32 transformation}]
[item modules/virtchannel_transform/hex.man         tcl::transform::hex       {Hexadecimal encoding transformation}]
[item modules/virtchannel_transform/identity.man    tcl::transform::identity  {Identity transformation}]
[item modules/virtchannel_transform/limitsize.man   tcl::transform::limitsize {limiting input}]
[item modules/virtchannel_transform/observe.man     tcl::transform::observe   {Observer transformation, stream copy}]
[item modules/virtchannel_transform/vt_otp.man      tcl::transform::otp       {Encryption via one-time pad}]
[item modules/virtchannel_transform/rot.man         tcl::transform::rot       rot-encryption]
[item modules/virtchannel_transform/spacer.man      tcl::transform::spacer    {Space insertation and removal}]
[item modules/virtchannel_transform/tcllib_zlib.man tcl::transform::zlib      {zlib (de)compression}]
[division_end]
[division_start Coroutine]
[item modules/coroutine/tcllib_coroutine.man coroutine       {Coroutine based event and IO handling}]
[item modules/coroutine/coro_auto.man        coroutine::auto {Automatic event and IO coroutine awareness}]
[division_end]
[division_start {Data structures}]
[item modules/counter/counter.man     counter             {Procedures for counters and histograms}]
[item modules/report/report.man       report              {Create and manipulate report objects}]
[item modules/struct/disjointset.man  struct::disjointset {Disjoint set data structure}]
[item modules/struct/graph.man        struct::graph       {Create and manipulate directed graph objects}]
[item modules/struct/graphops.man     struct::graph::op   {Operation for (un)directed graph objects}]
[item modules/struct/graph1.man       struct::graph_v1    {Create and manipulate directed graph objects}]
[item modules/struct/struct_list.man  struct::list        {Procedures for manipulating lists}]
[item modules/struct/matrix.man       struct::matrix      {Create and manipulate matrix objects}]
[item modules/struct/matrix1.man      struct::matrix_v1   {Create and manipulate matrix objects}]
[item modules/struct/pool.man         struct::pool        {Create and manipulate pool objects (of discrete items)}]
[item modules/struct/prioqueue.man    struct::prioqueue   {Create and manipulate prioqueue objects}]
[item modules/struct/queue.man        struct::queue       {Create and manipulate queue objects}]
[item modules/struct/record.man       struct::record      {Define and create records (similar to 'C' structures)}]
[item modules/struct/struct_set.man   struct::set         {Procedures for manipulating sets}]
[item modules/struct/skiplist.man     struct::skiplist    {Create and manipulate skiplists}]
[item modules/struct/stack.man        struct::stack       {Create and manipulate stack objects}]
[item modules/struct/struct_tree.man  struct::tree        {Create and manipulate tree objects}]
[item modules/struct/struct_tree1.man struct::tree_v1     {Create and manipulate tree objects}]
[item modules/treeql/treeql.man       treeql              {Query tree objects}]
[division_end]
[division_start {debugging, tracing, and logging}]
[item modules/debug/debug.man           debug            {debug narrative - core}]
[item modules/debug/debug_caller.man    debug::caller    {debug narrative - caller}]
[item modules/debug/debug_heartbeat.man debug::heartbeat {debug narrative - heartbeat}]
[item modules/debug/debug_timestamp.man debug::timestamp {debug narrative - timestamping}]
[division_end]
[division_start {Documentation tools}]
[item modules/doctools/docidx_intro.man           docidx_intro                {docidx introduction}]
[item modules/doctools/docidx_lang_cmdref.man     docidx_lang_cmdref          {docidx language command reference}]
[item modules/doctools/docidx_lang_faq.man        docidx_lang_faq             {docidx language faq}]
[item modules/doctools/docidx_lang_intro.man      docidx_lang_intro           {docidx language introduction}]
[item modules/doctools/docidx_lang_syntax.man     docidx_lang_syntax          {docidx language syntax}]
[item modules/doctools/docidx_plugin_apiref.man   docidx_plugin_apiref        {docidx plugin API reference}]
[item modules/docstrip/docstrip.man               docstrip                    {Docstrip style source code extraction}]
[item modules/docstrip/docstrip_util.man          docstrip_util               {Docstrip-related utilities}]
[item modules/doctools/doctoc_intro.man           doctoc_intro                {doctoc introduction}]
[item modules/doctools/doctoc_lang_cmdref.man     doctoc_lang_cmdref          {doctoc language command reference}]
[item modules/doctools/doctoc_lang_faq.man        doctoc_lang_faq             {doctoc language faq}]
[item modules/doctools/doctoc_lang_intro.man      doctoc_lang_intro           {doctoc language introduction}]
[item modules/doctools/doctoc_lang_syntax.man     doctoc_lang_syntax          {doctoc language syntax}]
[item modules/doctools/doctoc_plugin_apiref.man   doctoc_plugin_apiref        {doctoc plugin API reference}]
[item modules/doctools/doctools.man               doctools                    {doctools - Processing documents}]
[item modules/doctools2idx/idx_introduction.man   doctools2idx_introduction   {DocTools - Keyword indices}]
[item modules/doctools2toc/toc_introduction.man   doctools2toc_introduction   {DocTools - Tables of Contents}]
[item modules/doctools/changelog.man              doctools::changelog         {Processing text in Emacs ChangeLog format}]
[item modules/doctools/cvs.man                    doctools::cvs               {Processing text in 'cvs log' format}]
[item modules/doctools2base/html_cssdefaults.man  doctools::html::cssdefaults {Default CSS style for HTML export plugins}]
[item modules/doctools2idx/idx_container.man      doctools::idx               {Holding keyword indices}]
[item modules/doctools/docidx.man                 doctools::idx               {docidx - Processing indices}]
[item modules/doctools2idx/idx_export.man         doctools::idx::export       {Exporting keyword indices}]
[item modules/doctools2idx/idx_import.man         doctools::idx::import       {Importing keyword indices}]
[item modules/doctools2idx/idx_parse.man          doctools::idx::parse        {Parsing text in docidx format}]
[item modules/doctools2idx/idx_structure.man      doctools::idx::structure    {Docidx serialization utilities}]
[item modules/doctools2base/tcllib_msgcat.man     doctools::msgcat            {Message catalog management for the various document parsers}]
[item modules/doctools2idx/idx_msgcat_c.man       doctools::msgcat::idx::c    {Message catalog for the docidx parser (C)}]
[item modules/doctools2idx/idx_msgcat_de.man      doctools::msgcat::idx::de   {Message catalog for the docidx parser (DE)}]
[item modules/doctools2idx/idx_msgcat_en.man      doctools::msgcat::idx::en   {Message catalog for the docidx parser (EN)}]
[item modules/doctools2idx/idx_msgcat_fr.man      doctools::msgcat::idx::fr   {Message catalog for the docidx parser (FR)}]
[item modules/doctools2toc/toc_msgcat_c.man       doctools::msgcat::toc::c    {Message catalog for the doctoc parser (C)}]
[item modules/doctools2toc/toc_msgcat_de.man      doctools::msgcat::toc::de   {Message catalog for the doctoc parser (DE)}]
[item modules/doctools2toc/toc_msgcat_en.man      doctools::msgcat::toc::en   {Message catalog for the doctoc parser (EN)}]
[item modules/doctools2toc/toc_msgcat_fr.man      doctools::msgcat::toc::fr   {Message catalog for the doctoc parser (FR)}]
[item modules/doctools2base/nroff_manmacros.man   doctools::nroff::man_macros {Default CSS style for NROFF export plugins}]
[item modules/doctools2base/tcl_parse.man         doctools::tcl::parse        {Processing text in 'subst -novariables' format}]
[item modules/doctools2toc/toc_container.man      doctools::toc               {Holding tables of contents}]
[item modules/doctools/doctoc.man                 doctools::toc               {doctoc - Processing tables of contents}]
[item modules/doctools2toc/toc_export.man         doctools::toc::export       {Exporting tables of contents}]
[item modules/doctools2toc/toc_import.man         doctools::toc::import       {Importing keyword indices}]
[item modules/doctools2toc/toc_parse.man          doctools::toc::parse        {Parsing text in doctoc format}]
[item modules/doctools2toc/toc_structure.man      doctools::toc::structure    {Doctoc serialization utilities}]
[item modules/doctools/doctools_intro.man         doctools_intro              {doctools introduction}]
[item modules/doctools/doctools_lang_cmdref.man   doctools_lang_cmdref        {doctools language command reference}]
[item modules/doctools/doctools_lang_faq.man      doctools_lang_faq           {doctools language faq}]
[item modules/doctools/doctools_lang_intro.man    doctools_lang_intro         {doctools language introduction}]
[item modules/doctools/doctools_lang_syntax.man   doctools_lang_syntax        {doctools language syntax}]
[item modules/doctools/doctools_plugin_apiref.man doctools_plugin_apiref      {doctools plugin API reference}]
[item modules/dtplite/pkg_dtplite.man             dtplite                     {Lightweight DocTools Markup Processor}]
[item apps/dtplite.man                            dtplite                     {Lightweight DocTools Markup Processor}]
[item modules/doctools/mpexpand.man               mpexpand                    {Markup processor}]
[item apps/tcldocstrip.man                        tcldocstrip                 {Tcl-based Docstrip Processor}]
[item modules/tepam/tepam_doc_gen.man             tepam::doc_gen              {TEPAM DOC Generation, reference manual}]
[item modules/textutil/expander.man               textutil::expander          {Procedures to process templates and expand text.}]
[division_end]
[division_start File]
[item modules/zip/decode.man zipfile::decode {Access to zip archives}]
[item modules/zip/encode.man zipfile::encode {Generation of zip archives}]
[item modules/zip/mkzip.man  zipfile::mkzip  {Build a zip archive}]
[division_end]
[division_start {File formats}]
[item modules/gpx/gpx.man   gpx  {Extracts waypoints, tracks and routes from GPX files}]
[item modules/jpeg/jpeg.man jpeg {JPEG querying and manipulation of meta data}]
[item modules/png/png.man   png  {PNG querying and manipulation of meta data}]
[item modules/tar/tar.man   tar  {Tar file creation, extraction & manipulation}]
[item modules/tiff/tiff.man tiff {TIFF reading, writing, and querying and manipulation of meta data}]
[division_end]
[division_start {Grammars and finite automata}]
[item modules/grammar_aycock/aycock.man  grammar::aycock        {Aycock-Horspool-Earley parser generator for Tcl}]
[item modules/grammar_fa/fa.man          grammar::fa            {Create and manipulate finite automatons}]
[item modules/grammar_fa/dacceptor.man   grammar::fa::dacceptor {Create and use deterministic acceptors}]
[item modules/grammar_fa/dexec.man       grammar::fa::dexec     {Execute deterministic finite automatons}]
[item modules/grammar_fa/faop.man        grammar::fa::op        {Operations on finite automatons}]
[item modules/grammar_me/me_cpu.man      grammar::me::cpu       {Virtual machine implementation II for parsing token streams}]
[item modules/grammar_me/me_cpucore.man  grammar::me::cpu::core {ME virtual machine state manipulation}]
[item modules/grammar_me/gasm.man        grammar::me::cpu::gasm {ME assembler}]
[item modules/grammar_me/me_tcl.man      grammar::me::tcl       {Virtual machine implementation I for parsing token streams}]
[item modules/grammar_me/me_util.man     grammar::me::util      {AST utilities}]
[item modules/grammar_me/me_ast.man      grammar::me_ast        {Various representations of ASTs}]
[item modules/grammar_me/me_intro.man    grammar::me_intro      {Introduction to virtual machines for parsing token streams}]
[item modules/grammar_me/me_vm.man       grammar::me_vm         {Virtual machine for parsing token streams}]
[item modules/grammar_peg/peg.man        grammar::peg           {Create and manipulate parsing expression grammars}]
[item modules/grammar_peg/peg_interp.man grammar::peg::interp   {Interpreter for parsing expression grammars}]
[division_end]
[division_start {Hashes, checksums, and encryption}]
[item modules/aes/aes.man           aes       {Implementation of the AES block cipher}]
[item modules/blowfish/blowfish.man blowfish  {Implementation of the Blowfish block cipher}]
[item modules/crc/cksum.man         cksum     {Calculate a cksum(1) compatible checksum}]
[item modules/crc/crc16.man         crc16     {Perform a 16bit Cyclic Redundancy Check}]
[item modules/crc/crc32.man         crc32     {Perform a 32bit Cyclic Redundancy Check}]
[item modules/des/des.man           des       {Implementation of the DES and triple-DES ciphers}]
[item modules/md4/md4.man           md4       {MD4 Message-Digest Algorithm}]
[item modules/md5/md5.man           md5       {MD5 Message-Digest Algorithm}]
[item modules/md5crypt/md5crypt.man md5crypt  {MD5-based password encryption}]
[item modules/otp/otp.man           otp       {One-Time Passwords}]
[item modules/pki/pki.man           pki       {Implementation of the public key cipher}]
[item modules/rc4/rc4.man           rc4       {Implementation of the RC4 stream cipher}]
[item modules/ripemd/ripemd128.man  ripemd128 {RIPEMD-128 Message-Digest Algorithm}]
[item modules/ripemd/ripemd160.man  ripemd160 {RIPEMD-160 Message-Digest Algorithm}]
[item modules/sha1/sha1.man         sha1      {SHA1 Message-Digest Algorithm}]
[item modules/sha1/sha256.man       sha256    {SHA256 Message-Digest Algorithm}]
[item modules/soundex/soundex.man   soundex   Soundex]
[item modules/crc/sum.man           sum       {Calculate a sum(1) compatible checksum}]
[item modules/des/tcldes.man        tclDES    {Implementation of the DES and triple-DES ciphers}]
[item modules/des/tcldesjr.man      tclDESjr  {Implementation of the DES and triple-DES ciphers}]
[item modules/uuid/uuid.man         uuid      {UUID generation and comparison}]
[division_end]
[division_start Mathematics]
[item modules/math/math.man                    math                    {Tcl Math Library}]
[item modules/math/bigfloat.man                math::bigfloat          {Arbitrary precision floating-point numbers}]
[item modules/math/bignum.man                  math::bignum            {Arbitrary precision integer numbers}]
[item modules/math/calculus.man                math::calculus          {Integration and ordinary differential equations}]
[item modules/math/romberg.man                 math::calculus::romberg {Romberg integration}]
[item modules/math/combinatorics.man           math::combinatorics     {Combinatorial functions in the Tcl Math Library}]
[item modules/math/qcomplex.man                math::complexnumbers    {Straightforward complex number package}]
[item modules/math/constants.man               math::constants         {Mathematical and numerical constants}]
[item modules/math/decimal.man                 math::decimal           {General decimal arithmetic}]
[item modules/math/exact.man                   math::exact             {Exact Real Arithmetic}]
[item modules/math/fourier.man                 math::fourier           {Discrete and fast fourier transforms}]
[item modules/math/fuzzy.man                   math::fuzzy             {Fuzzy comparison of floating-point numbers}]
[item modules/math/math_geometry.man           math::geometry          {Geometrical computations}]
[item modules/math/interpolate.man             math::interpolate       {Interpolation routines}]
[item modules/math/linalg.man                  math::linearalgebra     {Linear Algebra}]
[item modules/math/numtheory.man               math::numtheory         {Number Theory}]
[item modules/math/optimize.man                math::optimize          {Optimisation routines}]
[item modules/math/pca.man                     math::PCA               {Package for Principal Component Analysis}]
[item modules/math/polynomials.man             math::polynomials       {Polynomial functions}]
[item modules/math/quasirandom.man             math::quasirandom       {Quasi-random points for integration and Monte Carlo type methods}]
[item modules/math/rational_funcs.man          math::rationalfunctions {Polynomial functions}]
[item modules/math/roman.man                   math::roman             {Tools for creating and manipulating roman numerals}]
[item modules/math/special.man                 math::special           {Special mathematical functions}]
[item modules/math/statistics.man              math::statistics        {Basic statistical functions and procedures}]
[item modules/math/trig.man                    math::trig              {Trigonometric anf hyperbolic functions}]
[item modules/simulation/annealing.man         simulation::annealing   {Simulated annealing}]
[item modules/simulation/montecarlo.man        simulation::montecarlo  {Monte Carlo simulations}]
[item modules/simulation/simulation_random.man simulation::random      {Pseudo-random number generators}]
[division_end]
[division_start Networking]
[item modules/asn/asn.man               asn                {ASN.1 BER encoder/decoder}]
[item modules/http/autoproxy.man        autoproxy          {Automatic HTTP proxy usage and authentication}]
[item modules/bee/bee.man               bee                {BitTorrent Serialization Format Encoder/Decoder}]
[item modules/dns/tcllib_dns.man        dns                {Tcl Domain Name Service Client}]
[item modules/ftp/ftp.man               ftp                {Client-side tcl implementation of the ftp protocol}]
[item modules/ftp/ftp_geturl.man        ftp::geturl        {Uri handler for ftp urls}]
[item modules/ftpd/ftpd.man             ftpd               {Tcl FTP server implementation}]
[item modules/httpd/httpd.man           httpd              {A TclOO and coroutine based web server}]
[item modules/ident/ident.man           ident              {Ident protocol client}]
[item modules/imap4/imap4.man           imap4              {imap client-side tcl implementation of imap protocol}]
[item modules/irc/irc.man               irc                {Create IRC connection and interface.}]
[item modules/ldap/ldap.man             ldap               {LDAP client}]
[item modules/ldap/ldapx.man            ldapx              {LDAP extended object interface}]
[item modules/nns/nns_client.man        nameserv           {Name service facility, Client}]
[item modules/nns/nns_auto.man          nameserv::auto     {Name service facility, Client Extension}]
[item modules/nns/nns_common.man        nameserv::common   {Name service facility, shared definitions}]
[item modules/nns/nns_protocol.man      nameserv::protocol {Name service facility, client/server protocol}]
[item modules/nns/nns_server.man        nameserv::server   {Name service facility, Server}]
[item modules/nmea/nmea.man             nmea               {Process NMEA data}]
[item apps/nns.man                      nns                {Name service facility, Commandline Client Application}]
[item modules/nns/nns_intro.man         nns_intro          {Name service facility, introduction}]
[item apps/nnsd.man                     nnsd               {Name service facility, Commandline Server Application}]
[item apps/nnslog.man                   nnslog             {Name service facility, Commandline Logging Client Application}]
[item modules/nntp/nntp.man             nntp               {Tcl client for the NNTP protocol}]
[item modules/ntp/ntp_time.man          ntp_time           {Tcl Time Service Client}]
[item modules/oauth/oauth.man           oauth              {oauth API base signature}]
[item modules/irc/picoirc.man           picoirc            {Small and simple embeddable IRC client.}]
[item modules/pop3/pop3.man             pop3               {Tcl client for POP3 email protocol}]
[item modules/pop3d/pop3d.man           pop3d              {Tcl POP3 server implementation}]
[item modules/pop3d/pop3d_dbox.man      pop3d::dbox        {Simple mailbox database for pop3d}]
[item modules/pop3d/pop3d_udb.man       pop3d::udb         {Simple user database for pop3d}]
[item modules/amazon-s3/S3.man          S3                 {Amazon S3 Web Service Interface}]
[item modules/sasl/sasl.man             SASL               {Implementation of SASL mechanisms for Tcl}]
[item modules/sasl/ntlm.man             SASL::NTLM         {Implementation of SASL NTLM mechanism for Tcl}]
[item modules/sasl/scram.man            SASL::SCRAM        {Implementation of SASL SCRAM mechanism for Tcl}]
[item modules/sasl/gtoken.man           SASL::XGoogleToken {Implementation of SASL NTLM mechanism for Tcl}]
[item modules/mime/smtp.man             smtp               {Client-side tcl implementation of the smtp protocol}]
[item modules/smtpd/smtpd.man           smtpd              {Tcl SMTP server implementation}]
[item modules/dns/tcllib_ip.man         tcllib_ip          {IPv4 and IPv6 address manipulation}]
[item modules/udpcluster/udpcluster.man udpcluster         {UDP Peer-to-Peer cluster}]
[item modules/uri/uri.man               uri                {URI utilities}]
[item modules/uri/urn-scheme.man        uri_urn            {URI utilities, URN scheme}]
[item modules/websocket/websocket.man   websocket          {Tcl implementation of the websocket protocol}]
[division_end]
[division_start {Page Parser Generator}]
[item apps/page.man                         page                 {Parser Generator}]
[item modules/page/page_intro.man           page_intro           {page introduction}]
[item modules/page/page_pluginmgr.man       page_pluginmgr       {page plugin manager}]
[item modules/page/page_util_flow.man       page_util_flow       {page dataflow/treewalker utility}]
[item modules/page/page_util_norm_lemon.man page_util_norm_lemon {page AST normalization, LEMON}]
[item modules/page/page_util_norm_peg.man   page_util_norm_peg   {page AST normalization, PEG}]
[item modules/page/page_util_peg.man        page_util_peg        {page PEG transformation utilities}]
[item modules/page/page_util_quote.man      page_util_quote      {page character quoting utilities}]
[division_end]
[division_start {Parsing and Grammars}]
[item apps/pt.man                             pt                                 {Parser Tools Application}]
[item modules/pt/pt_astree.man                pt::ast                            {Abstract Syntax Tree Serialization}]
[item modules/pt/pt_cparam_config_critcl.man  pt::cparam::configuration::critcl  {C/PARAM, Canned configuration, Critcl}]
[item modules/pt/pt_cparam_config_tea.man     pt::cparam::configuration::tea     {C/PARAM, Canned configuration, TEA}]
[item modules/pt/pt_json_language.man         pt::json_language                  {The JSON Grammar Exchange Format}]
[item modules/pt/pt_param.man                 pt::param                          {PackRat Machine Specification}]
[item modules/pt/pt_pexpression.man           pt::pe                             {Parsing Expression Serialization}]
[item modules/pt/pt_pexpr_op.man              pt::pe::op                         {Parsing Expression Utilities}]
[item modules/pt/pt_pegrammar.man             pt::peg                            {Parsing Expression Grammar Serialization}]
[item modules/pt/pt_peg_container.man         pt::peg::container                 {PEG Storage}]
[item modules/pt/pt_peg_container_peg.man     pt::peg::container::peg            {PEG Storage. Canned PEG grammar specification}]
[item modules/pt/pt_peg_export.man            pt::peg::export                    {PEG Export}]
[item modules/pt/pt_peg_export_container.man  pt::peg::export::container         {PEG Export Plugin. Write CONTAINER format}]
[item modules/pt/pt_peg_export_json.man       pt::peg::export::json              {PEG Export Plugin. Write JSON format}]
[item modules/pt/pt_peg_export_peg.man        pt::peg::export::peg               {PEG Export Plugin. Write PEG format}]
[item modules/pt/pt_peg_from_container.man    pt::peg::from::container           {PEG Conversion. From CONTAINER format}]
[item modules/pt/pt_peg_from_json.man         pt::peg::from::json                {PEG Conversion. Read JSON format}]
[item modules/pt/pt_peg_from_peg.man          pt::peg::from::peg                 {PEG Conversion. Read PEG format}]
[item modules/pt/pt_peg_import.man            pt::peg::import                    {PEG Import}]
[item modules/pt/pt_peg_import_container.man  pt::peg::import::container         {PEG Import Plugin. From CONTAINER format}]
[item modules/pt/pt_peg_import_json.man       pt::peg::import::json              {PEG Import Plugin. Read JSON format}]
[item modules/pt/pt_peg_import_peg.man        pt::peg::import::peg               {PEG Import Plugin. Read PEG format}]
[item modules/pt/pt_peg_interp.man            pt::peg::interp                    {Interpreter for parsing expression grammars}]
[item modules/pt/pt_peg_to_container.man      pt::peg::to::container             {PEG Conversion. Write CONTAINER format}]
[item modules/pt/pt_peg_to_cparam.man         pt::peg::to::cparam                {PEG Conversion. Write CPARAM format}]
[item modules/pt/pt_peg_to_json.man           pt::peg::to::json                  {PEG Conversion. Write JSON format}]
[item modules/pt/pt_peg_to_param.man          pt::peg::to::param                 {PEG Conversion. Write PARAM format}]
[item modules/pt/pt_peg_to_peg.man            pt::peg::to::peg                   {PEG Conversion. Write PEG format}]
[item modules/pt/pt_peg_to_tclparam.man       pt::peg::to::tclparam              {PEG Conversion. Write TCLPARAM format}]
[item modules/pt/pt_peg_language.man          pt::peg_language                   {PEG Language Tutorial}]
[item modules/pt/pt_peg_introduction.man      pt::pegrammar                      {Introduction to Parsing Expression Grammars}]
[item modules/pt/pt_pgen.man                  pt::pgen                           {Parser Generator}]
[item modules/pt/pt_rdengine.man              pt::rde                            {Parsing Runtime Support, PARAM based}]
[item modules/pt/pt_tclparam_config_nx.man    pt::tclparam::configuration::nx    {Tcl/PARAM, Canned configuration, NX}]
[item modules/pt/pt_tclparam_config_snit.man  pt::tclparam::configuration::snit  {Tcl/PARAM, Canned configuration, Snit}]
[item modules/pt/pt_tclparam_config_tcloo.man pt::tclparam::configuration::tcloo {Tcl/PARAM, Canned configuration, Tcloo}]
[item modules/pt/pt_util.man                  pt::util                           {General utilities}]
[item modules/pt/pt_to_api.man                pt_export_api                      {Parser Tools Export API}]
[item modules/pt/pt_from_api.man              pt_import_api                      {Parser Tools Import API}]
[item modules/pt/pt_introduction.man          pt_introduction                    {Introduction to Parser Tools}]
[item modules/pt/pt_parse_peg.man             pt_parse_peg                       {Parser Tools PEG Parser}]
[item modules/pt/pt_parser_api.man            pt_parser_api                      {Parser API}]
[item modules/pt/pt_peg_op.man                pt_peg_op                          {Parser Tools PE Grammar Utility Operations}]
[division_end]
[division_start {Procedures, arguments, parameters, options}]
[item modules/tepam/tepam_introduction.man tepam            {An introduction into TEPAM, Tcl's Enhanced Procedure and Argument Manager}]
[item modules/tepam/tepam_procedure.man    tepam::procedure {TEPAM procedure, reference manual}]
[division_end]
[division_start {Programming tools}]
[item modules/clay/clay.man               clay                      {A minimalist framework for large scale OO Projects}]
[item modules/cmdline/cmdline.man         cmdline                   {Procedures to process command lines and options.}]
[item modules/comm/comm.man               comm                      {A remote communication facility for Tcl (8.3 and later)}]
[item modules/comm/comm_wire.man          comm_wire                 {The comm wire protocol}]
[item modules/control/control.man         control                   {Procedures for control flow structures.}]
[item modules/interp/deleg_method.man     deleg_method              {Creation of comm delegates (snit methods)}]
[item modules/interp/deleg_proc.man       deleg_proc                {Creation of comm delegates (procedures)}]
[item modules/fileutil/fileutil.man       fileutil                  {Procedures implementing some file utilities}]
[item modules/fumagic/cfront.man          fileutil::magic::cfront   {Generator core for compiler of magic(5) files}]
[item modules/fumagic/cgen.man            fileutil::magic::cgen     {Generator core for compiler of magic(5) files}]
[item modules/fumagic/filetypes.man       fileutil::magic::filetype {Procedures implementing file-type recognition}]
[item modules/fumagic/rtcore.man          fileutil::magic::rt       {Runtime core for file type recognition engines written in pure Tcl}]
[item modules/fileutil/multi.man          fileutil::multi           {Multi-file operation, scatter/gather, standard object}]
[item modules/fileutil/multiop.man        fileutil::multi::op       {Multi-file operation, scatter/gather}]
[item modules/fileutil/traverse.man       fileutil_traverse         {Iterative directory traversal}]
[item modules/hook/hook.man               hook                      Hooks]
[item modules/interp/tcllib_interp.man    interp                    {Interp creation and aliasing}]
[item modules/log/log.man                 log                       {Procedures to log messages of libraries and applications.}]
[item modules/log/logger.man              logger                    {System to control logging of events.}]
[item modules/log/loggerAppender.man      logger::appender          {Collection of predefined appenders for logger}]
[item modules/log/loggerUtils.man         logger::utils             {Utilities for logger}]
[item modules/multiplexer/multiplexer.man multiplexer               {One-to-many communication with sockets.}]
[item modules/pluginmgr/pluginmgr.man     pluginmgr                 {Manage a plugin}]
[item modules/profiler/profiler.man       profiler                  {Tcl source code profiler}]
[item modules/snit/snit.man               snit                      {Snit's Not Incr Tcl}]
[item modules/snit/snitfaq.man            snitfaq                   {Snit Frequently Asked Questions}]
[item modules/stooop/stooop.man           stooop                    {Object oriented extension.}]
[item modules/stooop/switched.man         switched                  {switch/option management.}]
[item modules/tie/tie.man                 tie                       {Array persistence}]
[item modules/tie/tie_std.man             tie                       {Array persistence, standard data sources}]
[item modules/uev/uevent.man              uevent                    {User events}]
[item modules/wip/wip.man                 wip                       {Word Interpreter}]
[division_end]
[division_start System]
[item modules/cron/cron.man             cron       {Tool for automating the period callback of commands}]
[item modules/nettool/nettool.man       nettool    {Tools for networked applications}]
[item modules/processman/processman.man processman {Tool for automating the period callback of commands}]
[division_end]
[division_start TclOO]
[item modules/oometa/oometa.man   oometa  {oo::meta A data registry for classess}]
[item modules/practcl/practcl.man practcl {The Practcl Module}]
[item modules/tool/tool.man       tool    {TclOO Library (TOOL) Framework}]
[division_end]
[division_start {Terminal control}]
[item modules/term/term.man         term                     {General terminal control}]
[item modules/term/ansi_code.man    term::ansi::code         {Helper for control sequences}]
[item modules/term/ansi_cattr.man   term::ansi::code::attr   {ANSI attribute sequences}]
[item modules/term/ansi_cctrl.man   term::ansi::code::ctrl   {ANSI control sequences}]
[item modules/term/ansi_cmacros.man term::ansi::code::macros {Macro sequences}]
[item modules/term/ansi_ctrlu.man   term::ansi::ctrl::unix   {Control operations and queries}]
[item modules/term/ansi_send.man    term::ansi::send         {Output of ANSI control sequences to terminals}]
[item modules/term/imenu.man        term::interact::menu     {Terminal widget, menu}]
[item modules/term/ipager.man       term::interact::pager    {Terminal widget, paging}]
[item modules/term/receive.man      term::receive            {General input from terminals}]
[item modules/term/term_bind.man    term::receive::bind      {Keyboard dispatch from terminals}]
[item modules/term/term_send.man    term::send               {General output to terminals}]
[division_end]
[division_start {Text formatter plugin}]
[item modules/doctools2idx/export_docidx.man    doctools::idx::export::docidx {docidx export plugin}]
[item modules/doctools2idx/idx_export_html.man  doctools::idx::export::html   {HTML export plugin}]
[item modules/doctools2idx/idx_export_json.man  doctools::idx::export::json   {JSON export plugin}]
[item modules/doctools2idx/idx_export_nroff.man doctools::idx::export::nroff  {nroff export plugin}]
[item modules/doctools2idx/idx_export_text.man  doctools::idx::export::text   {plain text export plugin}]
[item modules/doctools2idx/idx_export_wiki.man  doctools::idx::export::wiki   {wiki export plugin}]
[item modules/doctools2idx/import_docidx.man    doctools::idx::import::docidx {docidx import plugin}]
[item modules/doctools2idx/idx_import_json.man  doctools::idx::import::json   {JSON import plugin}]
[item modules/doctools2toc/export_doctoc.man    doctools::toc::export::doctoc {doctoc export plugin}]
[item modules/doctools2toc/toc_export_html.man  doctools::toc::export::html   {HTML export plugin}]
[item modules/doctools2toc/toc_export_json.man  doctools::toc::export::json   {JSON export plugin}]
[item modules/doctools2toc/toc_export_nroff.man doctools::toc::export::nroff  {nroff export plugin}]
[item modules/doctools2toc/toc_export_text.man  doctools::toc::export::text   {plain text export plugin}]
[item modules/doctools2toc/toc_export_wiki.man  doctools::toc::export::wiki   {wiki export plugin}]
[item modules/doctools2toc/import_doctoc.man    doctools::toc::import::doctoc {doctoc import plugin}]
[item modules/doctools2toc/toc_import_json.man  doctools::toc::import::json   {JSON import plugin}]
[division_end]
[division_start {Text processing}]
[item modules/base64/ascii85.man           ascii85              {ascii85-encode/decode binary data}]
[item modules/base32/base32.man            base32               {base32 standard encoding}]
[item modules/base32/base32core.man        base32::core         {Expanding basic base32 maps}]
[item modules/base32/base32hex.man         base32::hex          {base32 extended hex encoding}]
[item modules/base64/base64.man            base64               {base64-encode/decode binary data}]
[item modules/bibtex/bibtex.man            bibtex               {Parse bibtex files}]
[item modules/clock/iso8601.man            clock_iso8601        {Parsing ISO 8601 dates/times}]
[item modules/clock/rfc2822.man            clock_rfc2822        {Parsing ISO 8601 dates/times}]
[item modules/csv/csv.man                  csv                  {Procedures to handle CSV data.}]
[item modules/htmlparse/htmlparse.man      htmlparse            {Procedures to parse HTML strings}]
[item modules/inifile/ini.man              inifile              {Parsing of Windows INI files}]
[item modules/markdown/markdown.man        markdown             {Converts Markdown text to HTML}]
[item modules/mime/mime.man                mime                 {Manipulation of MIME body parts}]
[item modules/rcs/rcs.man                  rcs                  {RCS low level utilities}]
[item modules/string/token.man             string::token        {Regex based iterative lexing}]
[item modules/string/token_shell.man       string::token::shell {Parsing of shell command line}]
[item modules/textutil/textutil.man        textutil             {Procedures to manipulate texts and strings.}]
[item modules/textutil/adjust.man          textutil::adjust     {Procedures to adjust, indent, and undent paragraphs}]
[item modules/textutil/patch.man           textutil::patch      {Application of uni-diff patches to directory trees}]
[item modules/textutil/repeat.man          textutil::repeat     {Procedures to repeat strings.}]
[item modules/textutil/textutil_split.man  textutil::split      {Procedures to split texts}]
[item modules/textutil/textutil_string.man textutil::string     {Procedures to manipulate texts and strings.}]
[item modules/textutil/tabify.man          textutil::tabify     {Procedures to (un)tabify strings}]
[item modules/textutil/trim.man            textutil::trim       {Procedures to trim strings}]
[item modules/base64/uuencode.man          uuencode             {UU-encode/decode binary data}]
[item modules/amazon-s3/xsxp.man           xsxp                 {eXtremely Simple Xml Parser}]
[item modules/base64/yencode.man           yencode              {Y-encode/decode binary data}]
[division_end]
[division_start {Transfer module}]
[item modules/transfer/connect.man     transfer::connect           {Connection setup}]
[item modules/transfer/copyops.man     transfer::copy              {Data transfer foundation}]
[item modules/transfer/tqueue.man      transfer::copy::queue       {Queued transfers}]
[item modules/transfer/ddest.man       transfer::data::destination {Data destination}]
[item modules/transfer/dsource.man     transfer::data::source      {Data source}]
[item modules/transfer/receiver.man    transfer::receiver          {Data source}]
[item modules/transfer/transmitter.man transfer::transmitter       {Data source}]
[division_end]
[division_start Unfiled]
[item modules/cache/async.man                cache::async             {Asynchronous in-memory cache}]
[item modules/fileutil/paths.man             fileutil::paths          {Manage search path pools}]
[item modules/generator/generator.man        generator                {Procedures for creating and using generators.}]
[item modules/yaml/huddle.man                huddle                   {Create and manipulate huddle object}]
[item modules/map/map_geocode_nominatim.man  map::geocode::nominatim  {Resolving geographical names with a Nominatim service}]
[item modules/map/map_slippy.man             map::slippy              {Common code for slippy based map packages}]
[item modules/map/map_slippy_cache.man       map::slippy::cache       {Management of a tile cache in the local filesystem}]
[item modules/map/map_slippy_fetcher.man     map::slippy::fetcher     {Accessing a server providing tiles for slippy-based maps}]
[item modules/mapproj/mapproj.man            mapproj                  {Map projection routines}]
[item modules/math/symdiff.man               math::calculus::symdiff  {Symbolic differentiation for Tcl}]
[item modules/namespacex/namespacex.man      namespacex               {Namespace utility commands}]
[item modules/rest/rest.man                  rest                     {define REST web APIs and call them inline or asychronously}]
[item modules/stringprep/stringprep.man      stringprep               {Implementation of stringprep}]
[item modules/stringprep/stringprep_data.man stringprep::data         {stringprep data tables, generated, internal}]
[item modules/struct/struct_map.man          struct::map              {Manage key/value maps}]
[item modules/math/machineparameters.man     tclrep/machineparameters {Compute double precision machine parameters.}]
[item modules/uev/uevent_onidle.man          uevent::onidle           {Request merging and deferal to idle time}]
[item modules/stringprep/unicode.man         unicode                  {Implementation of Unicode normalization}]
[item modules/stringprep/unicode_data.man    unicode::data            {unicode data tables, generated, internal}]
[item modules/units/units.man                units                    {unit conversion}]
[item modules/yaml/yaml.man                  yaml                     {YAML Format Encoder/Decoder}]
[division_end]
[division_start Utilities]
[item modules/dicttool/dicttool.man dicttool {Dictionary Tools}]
[division_end]
[division_start Utility]
[item modules/defer/defer.man             defer               {Defered execution}]
[item modules/lambda/lambda.man           lambda              {Utility commands for anonymous procedures}]
[item modules/lazyset/lazyset.man         lazyset             {Lazy evaluation}]
[item modules/ooutil/ooutil.man           oo::util            {Utility commands for TclOO}]
[item modules/tool/meta.man               oo::util            {Utility commands for TclOO}]
[item modules/try/tcllib_throw.man        throw               {throw - Throw an error exception with a message}]
[item modules/tool/tool_dict_ensemble.man tool::dict_ensemble {Dictionary Tools}]
[item modules/try/tcllib_try.man          try                 {try - Trap and process errors and exceptions}]
[division_end]
[division_start {Validation, Type checking}]
[item modules/valtype/valtype_common.man valtype::common                 {Validation, common code}]
[item modules/valtype/cc_amex.man        valtype::creditcard::amex       {Validation for AMEX creditcard number}]
[item modules/valtype/cc_discover.man    valtype::creditcard::discover   {Validation for Discover creditcard number}]
[item modules/valtype/cc_mastercard.man  valtype::creditcard::mastercard {Validation for Mastercard creditcard number}]
[item modules/valtype/cc_visa.man        valtype::creditcard::visa       {Validation for VISA creditcard number}]
[item modules/valtype/ean13.man          valtype::gs1::ean13             {Validation for EAN13}]
[item modules/valtype/iban.man           valtype::iban                   {Validation for IBAN}]
[item modules/valtype/imei.man           valtype::imei                   {Validation for IMEI}]
[item modules/valtype/isbn.man           valtype::isbn                   {Validation for ISBN}]
[item modules/valtype/luhn.man           valtype::luhn                   {Validation for plain number with a LUHN checkdigit}]
[item modules/valtype/luhn5.man          valtype::luhn5                  {Validation for plain number with a LUHN5 checkdigit}]
[item modules/valtype/usnpi.man          valtype::usnpi                  {Validation for USNPI}]
[item modules/valtype/verhoeff.man       valtype::verhoeff               {Validation for plain number with a VERHOEFF checkdigit}]
[division_end]
[division_end]
[toc_end]