=head1 SEE ALSO

A mailing list exists for up-to-date information on the Template Toolkit
and for following and contributing to the development process.  Send 
email to B<majordomo@cre.canon.co.uk> with the following message in the
body:

    subscribe templates

The F<tpage> and F<ttree> scripts are distributed and installed along
with the Template Toolkit.  The F<tpage> script simply processes named 
files or STDIN if unspecified, using a default Template object.  The 
F<ttree> script can be used to process entire directory trees of templates,
allowing large content systems such as web sites to be rebuilt from a 
single command or configuration file.

    perldoc tpage
    perldoc ttree

The following modules comprise the Template Toolkit.  Consult the 
individual documentation for further details. 

=over 4

=item L<Template::Context|Template::Context>

The Template::Context module defines a class of objects which each represent
a unique run-time environment in which templates are rendered.  The 
context maintains references to the stash of variables currently defined
(L<Template::Stash|Template::Stash>) and to a cache object 
(L<Template::Cache|Template::Cache>) which provides access to template
files.  It also defines the output() method through which template output 
is directed and provides the error() and throw() methods for error 
handling.  The main process() method is called to render a template
within the context.

=item L<Template::Stash|Template::Stash>

The Template::Stash module defines an object class which is used for 
storing, retrieving and evaluating variables and their values for 
run-time access and processing by templates.  

=item L<Template::Cache|Template::Cache>

The Template::Cache module defines an object class which is used to 
find, load, parse, compile and then cache template documents.  The 
cache implements a simple fetch($template) method which will accept 
a wide range of inputs (filename, text ref, GLOB, IO::Handle, etc)
and attempt to read the template and call on a 
L<Template::Parser|Template::Parser> to parse and compile it to an 
internal form.  This is then cached for subsequent fetch() calls 
for the same template.

=item L<Template::Parser|Template::Parser>

The Template::Parser module defines an object class which implements
the template parser and compiler.  The template text is first scanned 
by a Perl regex which breaks the text into chunks and lexes the tokens
within directive tags.  A DFA (Deterministic Finite-State Automation)
then iterates through the tokens using the rules and states defined
in L<Template::Grammar|Template::Grammar> and generates a compiled
template document represented by the root node of a tree of 
L<Template::Directive|Template::Directive> objects.  The rendering 
context may then call the process() method of the root node, passing 
itself as a reference, to render the template.

=item L<Template::Grammar|Template::Grammar>

The Template::Grammar module defines the rules and state tables for 
the L<Template::Parser|Template::Parser> DFA.  These are generated 
by the Parse::Yapp module.  The Template-Toolkit distribution 
contains a B<parser> directory which contains further files and 
information concerning the grammar and compilation thereof.

=item L<Template::Directive|Template::Directive>

The Template::Directive module defines a base class and a number of 
derived specialist classes to represent directives within template 
documents.  These are instantiated by the 
L<Template::Parser|Template::Parser> object from actions defined in 
L<Template::Grammar|Template::Grammar>.

=item L<Template::Exception|Template::Exception>

The Template::Exception module defines a primitive exception type 
for representing error conditions within the Template Toolkit.

=item L<Template::Iterator|Template::Iterator>

The Template::Iterator module defines a data iterator which is used 
by the FOREACH directive.  This may be sub-classed to create more 
specialised iterators for traversing data sets.

=item L<Template::Plugin|Template::Plugin>

The Template::Plugin module defines a base class for Template Toolkit
extension modules that can be loaded via the USE directive.

=item L<Template::Plugin::Filter|Template::Plugin::Filter>

A specific plugin module which implements the FILTER methods.

=item L<Template::Constants|Template::Constants>

Defines various constants used in the Template Toolkit.

=item L<Template::Utils|Template::Utils>

Defines utility functions.

=item L<Template::Debug|Template::Debug>

Defines functions and methods for debugging (incomplete).

=back


