File: Directives.html

package info (click to toggle)
libtemplate-perl 2.24-1
links: PTS
area: main
in suites: wheezy
size: 8,660 kB
sloc: perl: 14,518; makefile: 15; sh: 5
file content (2381 lines) | stat: -rwxr-xr-x 122,578 bytes
parent folder | download | duplicates (2)


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN">
<html>
  <head>
    <title>Template::Manual::Directives</title>
    <link rel="stylesheet" type="text/css" href="../css/blue.css" title="Clear Blue">
    <link rel="alternate stylesheet" type="text/css" href="../css/orange.css" title="Clear Orange">
    <link rel="alternate stylesheet" type="text/css" href="../css/green.css" title="Clear Green">
    <link rel="alternate stylesheet" type="text/css" href="../css/purple.css" title="Clear Purple">
    <link rel="alternate stylesheet" type="text/css" href="../css/grey.css" title="Clear Grey">
    <!--[if IE 6]>
    <link rel="stylesheet" type="text/css" href="../css/ie6.css" />
    <![endif]-->
    <link rel="stylesheet" type="text/css" href="/css/print.css" media="print">
    <script type="text/javascript" src="../js/tt2.js"></script>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
    <meta name="author" content="Andy Wardley">
  </head>
  <body id="body"> 
    <div id="layout">
        <div id="header">
          <a href="../index.html" id="logo" alt="" title="Click for the Home Page"><span class="alt">TT2 Home Page</span></a>
          <ul id="trail">
            <li><a href="../manual/index.html">Manual</a></li>
            <li class="last"><a href="../manual/Directives.html">Directives</a></li>
          </ul>
          <div class="controls">
            <a href="#" class="menu show" onclick="widescreen_off(); return false" title="Show Menu">
              <span class="about">Click to view the menu.  It's very nice.</span>
            </a>
            <a href="#" class="menu hide" onclick="widescreen_on();  return false" title="Hide Menu">
              <span class="about">Click to hide the menu and go all widescreen!</span>
            </a>
          
          <div class="pager">
            <a href="../manual/Syntax.html" title="Template::Manual::Syntax" class="go back">Back<span class="about"><h4>Template::Manual::Syntax</h4>Directive syntax, structure and semantics</span></a>
            <a href="../manual/index.html" title="Template::Manual" class="go up">Up<span class="about"><h4>Template::Manual</h4>Template Toolkit User Manual</span></a>
            <a href="../manual/Variables.html" title="Template::Manual::Variables" class="go next">Next<span class="about"><h4>Template::Manual::Variables</h4>Template variables and code bindings</span></a>
          </div>
          </div>
          <h1 class="headline">Template::Manual::Directives</h1>
          <h2 class="subhead">Template directives</h1>
        
        </div>
        <div id="page">
          <div id="sidebar">
            <a href="../index.html" id="logo"></a>
            <div id="menu">
              <ul class="menu">
                <li class="l0 first"><a href="../manual/index.html" class="warm">Manual</a></li>
                <li class="l1"><a href="../manual/Intro.html">Intro</a></li>
                <li class="l1"><a href="../manual/Syntax.html">Syntax</a></li>
                <li class="l1"><a href="../manual/Directives.html" class="warm">Directives</a></li>
                <li class="l1"><a href="../manual/Variables.html">Variables</a></li>
                <li class="l1"><a href="../manual/VMethods.html">VMethods</a></li>
                <li class="l1"><a href="../manual/Config.html">Config</a></li>
                <li class="l1"><a href="../manual/Filters.html">Filters</a></li>
                <li class="l1"><a href="../manual/Plugins.html">Plugins</a></li>
                <li class="l1"><a href="../manual/Internals.html">Internals</a></li>
                <li class="l1"><a href="../manual/Views.html">Views</a></li>
                <li class="l1"><a href="../manual/Credits.html">Credits</a></li>
                <li class="l0"><a href="../modules/index.html">Modules</a></li>
                <li class="l0"><a href="../tools/index.html">Tools</a></li>
                <li class="l0 last"><a href="../tutorial/index.html">Tutorial</a></li>
              </ul>
              <div class="foot"></div>
            </div>
          </div>
          <div id="content">
          <div class="section">
            <div class="head">
              <h1 id="contents" onclick="switch_section(this)" title="Click title to show/hide section content.">Contents</h1>
              <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
            </div>
            <div class="body">
              <ul class="toc">
                  <li class=""><a href="#Accessing_and_Updating_Template_Variables">Accessing and Updating Template Variables</a></li>
                  <li class="sub"><a href="#section_GET">GET</a></li>
                  <li class="sub"><a href="#section_CALL">CALL</a></li>
                  <li class="sub"><a href="#section_SET">SET</a></li>
                  <li class="sub"><a href="#section_DEFAULT">DEFAULT</a></li>
                  <li class=""><a href="#Processing_Template_Files_and_Blocks">Processing Template Files and Blocks</a></li>
                  <li class="sub"><a href="#section_INSERT">INSERT</a></li>
                  <li class="sub"><a href="#section_INCLUDE">INCLUDE</a></li>
                  <li class="sub"><a href="#section_PROCESS">PROCESS</a></li>
                  <li class="sub"><a href="#section_WRAPPER">WRAPPER</a></li>
                  <li class="sub"><a href="#section_BLOCK">BLOCK</a></li>
                  <li class=""><a href="#Conditional_Processing">Conditional Processing</a></li>
                  <li class="sub"><a href="#section_IF_UNLESS_ELSIF_ELSE">IF / UNLESS / ELSIF / ELSE</a></li>
                  <li class="sub"><a href="#section_SWITCH_CASE">SWITCH / CASE</a></li>
                  <li class=""><a href="#Loop_Processing">Loop Processing</a></li>
                  <li class="sub"><a href="#section_FOREACH">FOREACH</a></li>
                  <li class="sub"><a href="#section_WHILE">WHILE</a></li>
                  <li class=""><a href="#Filters_Plugins_Macros_and_Perl">Filters, Plugins, Macros and Perl</a></li>
                  <li class="sub"><a href="#section_FILTER">FILTER</a></li>
                  <li class="sub"><a href="#section_USE">USE</a></li>
                  <li class="sub"><a href="#section_MACRO">MACRO</a></li>
                  <li class="sub"><a href="#section_PERL">PERL</a></li>
                  <li class="sub"><a href="#section_RAWPERL">RAWPERL</a></li>
                  <li class=""><a href="#Exception_Handling_and_Flow_Control">Exception Handling and Flow Control</a></li>
                  <li class="sub"><a href="#section_TRY_THROW_CATCH_FINAL">TRY / THROW / CATCH / FINAL</a></li>
                  <li class="sub"><a href="#section_NEXT">NEXT</a></li>
                  <li class="sub"><a href="#section_LAST">LAST</a></li>
                  <li class="sub"><a href="#section_RETURN">RETURN</a></li>
                  <li class="sub"><a href="#section_STOP">STOP</a></li>
                  <li class="sub"><a href="#section_CLEAR">CLEAR</a></li>
                  <li class=""><a href="#Miscellaneous">Miscellaneous</a></li>
                  <li class="sub"><a href="#section_META">META</a></li>
                  <li class="sub"><a href="#section_TAGS">TAGS</a></li>
                  <li class="sub"><a href="#section_DEBUG">DEBUG</a></li>
              
              </ul>
            </div>
          </div>
          
                <div class="pod">
            <div class="section">
              <div class="head">
                <h1 id="Accessing_and_Updating_Template_Variables" onclick="switch_section(this)" title="Click title to show/hide section content.">Accessing and Updating Template Variables</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_GET" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">GET</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>GET</code> directive retrieves and outputs the value of the
                          named variable.
                        </p>
                        <pre>[% GET foo %]</pre>
                        <p>
                          The <code>GET</code> keyword is optional. A variable can be specified in
                          a directive tag by itself.
                        </p>
                        <pre>[% foo %]</pre>
                        <p>
                          The variable can have an unlimited number of elements, each separated by
                          a dot. Each element can have arguments specified within parentheses.
                        </p>
                        <pre>[% foo %]
[% bar.baz %]
[% biz.baz(10) %]
...etc...</pre>
                        <p>
                          See <a href="../manual/Variables.html">Template::Manual::Variables</a> for a full discussion on template
                          variables.
                        </p>
                        <p>
                          You can also specify expressions using the logical (<code>and</code>,
                          <code>or</code>, <code>not</code>, <code>?</code>, <code>:</code>) and
                          mathematic operators (<code>+</code>, <code>-</code>, <code>*</code>,
                          <code>/</code>, <code>%</code>, <code>mod</code>, <code>div</code>).
                        </p>
                        <pre>[% template.title or default.title %]

[% score * 100 %]

[% order.nitems ? checkout(order.total) : 'no items' %]</pre>
                        <p>
                          The <code>div</code> operator returns the integer result of division.
                          Both <code>%</code> and <code>mod</code> return the modulus (i.e.
                          remainder) of division.
                        </p>
                        <pre>[% 15 / 6 %]            # 2.5
[% 15 div 6 %]          # 2
[% 15 mod 6 %]          # 3</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_CALL" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">CALL</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>CALL</code> directive is similar to <code>GET</code> in
                          evaluating the variable named, but doesn't print the result returned.
                          This can be useful when a variable is bound to a sub-routine or object
                          method which you want to call but aren't interested in the value
                          returned.
                        </p>
                        <pre>[% CALL dbi.disconnect %]

[% CALL inc_page_counter(page_count) %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_SET" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">SET</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>SET</code> directive allows you to assign new values to
                          existing variables or create new temporary variables.
                        </p>
                        <pre>[% SET title = 'Hello World' %]</pre>
                        <p>
                          The <code>SET</code> keyword is also optional. [% title = 'Hello World'
                          %]
                        </p>
                        <p>
                          Variables may be assigned the values of other variables, unquoted numbers
                          (2.718), literal text ('single quotes') or quoted text ("double quotes").
                          In the latter case, any variable references within the text will be
                          interpolated when the string is evaluated. Variables should be prefixed
                          by <code>$</code>, using curly braces to explicitly scope the variable
                          name where necessary.
                        </p>
                        <pre>[% foo  = 'Foo'  %]               # literal value 'Foo'
[% bar  =  foo   %]               # value of variable 'foo'
[% cost = '$100' %]               # literal value '$100'
[% item = "$bar: ${cost}.00" %]   # value "Foo: $100.00"</pre>
                        <p>
                          Multiple variables may be assigned in the same directive and are
                          evaluated in the order specified. Thus, the above could have been
                          written:
                        </p>
                        <pre>[% foo  = 'Foo'
   bar  = foo
   cost = '$100'
   item = "$bar: ${cost}.00"
%]</pre>
                        <p>
                          Simple expressions can also be used, as per <code>GET</code>.
                        </p>
                        <pre>[% ten    = 10 
   twenty = 20
   thirty = twenty + ten
   forty  = 2 * twenty 
   fifty  = 100 div 2
   six    = twenty mod 7
%]</pre>
                        <p>
                          You can concatenate strings together using the <code>' _ '</code>
                          operator. In Perl 5, the <code>.</code> is used for string concatenation,
                          but in Perl 6, as in the Template Toolkit, the <code>.</code> will be
                          used as the method calling operator and <code>' _ '</code> will be used
                          for string concatenation. Note that the operator must be specified with
                          surrounding whitespace which, as Larry says, is construed as a feature:
                        </p>
                        <pre>[% copyright = '(C) Copyright' _ year _ ' ' _ author %]</pre>
                        <p>
                          You can, of course, achieve a similar effect with double quoted string
                          interpolation.
                        </p>
                        <pre>[% copyright = "(C) Copyright $year $author" %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_DEFAULT" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">DEFAULT</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>DEFAULT</code> directive is similar to <code>SET</code> but
                          only updates variables that are currently undefined or have no "true"
                          value (in the Perl sense).
                        </p>
                        <pre>[% DEFAULT
    name = 'John Doe'
    id   = 'jdoe'
%]</pre>
                        <p>
                          This can be particularly useful in common template components to ensure
                          that some sensible default are provided for otherwise undefined
                          variables.
                        </p>
                        <pre>[% DEFAULT 
   title = 'Hello World'
   bgcol = '#ffffff'
%]
&lt;html&gt;
  &lt;head&gt;
    &lt;title&gt;[% title %]&lt;/title&gt;
  &lt;/head&gt;
  &lt;body bgcolor="[% bgcol %]"&gt;
    ...etc...</pre>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Processing_Template_Files_and_Blocks" onclick="switch_section(this)" title="Click title to show/hide section content.">Processing Template Files and Blocks</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_INSERT" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">INSERT</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>INSERT</code> directive is used to insert the contents of an
                          external file at the current position.
                        </p>
                        <pre>[% INSERT myfile %]</pre>
                        <p>
                          No attempt to parse or process the file is made. The contents, possibly
                          including any embedded template directives, are inserted intact.
                        </p>
                        <p>
                          The filename specified should be relative to one of the
                          <code>INCLUDE_PATH</code> directories. Absolute (i.e. starting with
                          <code>/</code>) and relative (i.e. starting with <code>.</code>)
                          filenames may be used if the <code>ABSOLUTE</code> and
                          <code>RELATIVE</code> options are set, respectively. Both these options
                          are disabled by default.
                        </p>
                        <pre>my $template = Template-&gt;new({
    INCLUDE_PATH =&gt; '/here:/there',
});

$template-&gt;process('myfile');</pre>
                        <p>
                          <i>myfile</i>:
                        </p>
                        <pre>[% INSERT foo %]            # looks for /here/foo then /there/foo
[% INSERT /etc/passwd %]    # file error: ABSOLUTE not set
[% INSERT ../secret %]      # file error: RELATIVE not set</pre>
                        <p>
                          For convenience, the filename does not need to be quoted as long as it
                          contains only alphanumeric characters, underscores, dots or forward
                          slashes. Names containing any other characters should be quoted.
                        </p>
                        <pre>[% INSERT misc/legalese.txt            %]
[% INSERT 'dos98/Program Files/stupid' %]</pre>
                        <p>
                          To evaluate a variable to specify a filename, you should explicitly
                          prefix it with a <code>$</code> or use double-quoted string
                          interpolation.
                        </p>
                        <pre>[% language = 'en'
   legalese = 'misc/legalese.txt' 
%]

[% INSERT $legalese %]              # misc/legalese.txt
[% INSERT "$language/$legalese" %]  # en/misc/legalese.txt</pre>
                        <p>
                          Multiple files can be specified using <code>+</code> as a delimiter. All
                          files should be unquoted names or quoted strings. Any variables should be
                          interpolated into double-quoted strings.
                        </p>
                        <pre>[% INSERT legalese.txt + warning.txt %]
[% INSERT  "$legalese" + warning.txt %]  # requires quoting</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_INCLUDE" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">INCLUDE</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>INCLUDE</code> directive is used to process and include the
                          output of another template file or block.
                        </p>
                        <pre>[% INCLUDE header %]</pre>
                        <p>
                          If a <code>BLOCK</code> of the specified name is defined in the same
                          file, or in a file from which the current template has been called (i.e.
                          a parent template) then it will be used in preference to any file of the
                          same name.
                        </p>
                        <pre>[% INCLUDE table %]     # uses BLOCK defined below

[% BLOCK table %]
   &lt;table&gt;
     ...
   &lt;/table&gt;
[% END %]</pre>
                        <p>
                          If a <code>BLOCK</code> definition is not currently visible then the
                          template name should be a file relative to one of the
                          <code>INCLUDE_PATH</code> directories, or an absolute or relative file
                          name if the <code>ABSOLUTE</code>/<code>RELATIVE</code> options are
                          appropriately enabled. The <code>INCLUDE</code> directive automatically
                          quotes the filename specified, as per <code>INSERT</code> described
                          above. When a variable contains the name of the template for the
                          <code>INCLUDE</code> directive, it should be explicitly prefixed by
                          <code>$</code> or double-quoted
                        </p>
                        <pre>[% myheader = 'my/misc/header' %]
[% INCLUDE   myheader  %]           # 'myheader'
[% INCLUDE  $myheader  %]           # 'my/misc/header'
[% INCLUDE "$myheader" %]           # 'my/misc/header'</pre>
                        <p>
                          Any template directives embedded within the file will be processed
                          accordingly. All variables currently defined will be visible and
                          accessible from within the included template.
                        </p>
                        <pre>[% title = 'Hello World' %]
[% INCLUDE header %]
&lt;body&gt;
...</pre>
                        <p>
                          <i>header</i>:
                        </p>
                        <pre>&lt;html&gt;
&lt;title&gt;[% title %]&lt;/title&gt;</pre>
                        <p>
                          output:
                        </p>
                        <pre>&lt;html&gt;
&lt;title&gt;Hello World&lt;/title&gt;
&lt;body&gt;
...</pre>
                        <p>
                          Local variable definitions may be specified after the template name,
                          temporarily masking any existing variables. Insignificant whitespace is
                          ignored within directives so you can add variable definitions on the same
                          line, the next line or split across several line with comments
                          interspersed, if you prefer.
                        </p>
                        <pre>[% INCLUDE table %]

[% INCLUDE table title="Active Projects" %]

[% INCLUDE table 
     title   = "Active Projects" 
     bgcolor = "#80ff00"    # chartreuse
     border  = 2
%]</pre>
                        <p>
                          The <code>INCLUDE</code> directive localises (i.e. copies) all variables
                          before processing the template. Any changes made within the included
                          template will not affect variables in the including template.
                        </p>
                        <pre>[% foo = 10 %]

foo is originally [% foo %]
[% INCLUDE bar %]
foo is still [% foo %]

[% BLOCK bar %]
   foo was [% foo %]
   [% foo = 20 %]
   foo is now [% foo %]
[% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>foo is originally 10
   foo was 10
   foo is now 20
foo is still 10</pre>
                        <p>
                          Technical Note: the localisation of the stash (that is, the process by
                          which variables are copied before an <code>INCLUDE</code> to prevent
                          being overwritten) is only skin deep. The top-level variable namespace
                          (hash) is copied, but no attempt is made to perform a deep-copy of other
                          structures (hashes, arrays, objects, etc.) Therefore, a <code>foo</code>
                          variable referencing a hash will be copied to create a new
                          <code>foo</code> variable but which points to the same hash array. Thus,
                          if you update compound variables (e.g. <code>foo.bar</code>) then you
                          will change the original copy, regardless of any stash localisation. If
                          you're not worried about preserving variable values, or you trust the
                          templates you're including then you might prefer to use the
                          <code>PROCESS</code> directive which is faster by virtue of not
                          performing any localisation.
                        </p>
                        <p>
                          You can specify dotted variables as "local" variables to an
                          <code>INCLUDE</code> directive. However, be aware that because of the
                          localisation issues explained above (if you skipped the previous
                          Technical Note above then you might want to go back and read it or skip
                          this section too), the variables might not actualy be "local". If the
                          first element of the variable name already references a hash array then
                          the variable update will affect the original variable.
                        </p>
                        <pre>[% foo = {
       bar = 'Baz'
   }
%]

[% INCLUDE somefile foo.bar='Boz' %]

[% foo.bar %]           # Boz</pre>
                        <p>
                          This behaviour can be a little unpredictable (and may well be improved
                          upon in a future version). If you know what you're doing with it and
                          you're sure that the variables in question are defined (nor not) as you
                          expect them to be, then you can rely on this feature to implement some
                          powerful "global" data sharing techniques. Otherwise, you might prefer to
                          steer well clear and always pass simple (undotted) variables as
                          parameters to <code>INCLUDE</code> and other similar directives.
                        </p>
                        <p>
                          If you want to process several templates in one go then you can specify
                          each of their names (quoted or unquoted names only, no unquoted
                          <code>$variables</code>) joined together by <code>+</code>. The
                          <code>INCLUDE</code> directive will then process them in order.
                        </p>
                        <pre>[% INCLUDE html/header + "site/$header" + site/menu
     title = "My Groovy Web Site"
%]</pre>
                        <p>
                          The variable stash is localised once and then the templates specified are
                          processed in order, all within that same variable context. This makes it
                          slightly faster than specifying several separate <code>INCLUDE</code>
                          directives (because you only clone the variable stash once instead of n
                          times), but not quite as "safe" because any variable changes in the first
                          file will be visible in the second, third and so on. This might be what
                          you want, of course, but then again, it might not.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_PROCESS" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">PROCESS</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The PROCESS directive is similar to <code>INCLUDE</code> but does not
                          perform any localisation of variables before processing the template. Any
                          changes made to variables within the included template will be visible in
                          the including template.
                        </p>
                        <pre>[% foo = 10 %]

foo is [% foo %]
[% PROCESS bar %]
foo is [% foo %]

[% BLOCK bar %]
   [% foo = 20 %]
   changed foo to [% foo %]
[% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>foo is 10
   changed foo to 20
foo is 20</pre>
                        <p>
                          Parameters may be specified in the <code>PROCESS</code> directive, but
                          these too will become visible changes to current variable values.
                        </p>
                        <pre>[% foo = 10 %]
foo is [% foo %]
[% PROCESS bar
   foo = 20 
%]
foo is [% foo %]

[% BLOCK bar %]
   this is bar, foo is [% foo %]
[% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>foo is 10
   this is bar, foo is 20
foo is 20</pre>
                        <p>
                          The <code>PROCESS</code> directive is slightly faster than
                          <code>INCLUDE</code> because it avoids the need to localise (i.e. copy)
                          the variable stash before processing the template. As with
                          <code>INSERT</code> and <code>INCLUDE</code>, the first parameter does
                          not need to be quoted as long as it contains only alphanumeric
                          characters, underscores, periods or forward slashes. A <code>$</code>
                          prefix can be used to explicitly indicate a variable which should be
                          interpolated to provide the template name:
                        </p>
                        <pre>[% myheader = 'my/misc/header' %]
[% PROCESS  myheader %]              # 'myheader'
[% PROCESS $myheader %]              # 'my/misc/header'</pre>
                        <p>
                          As with <code>INCLUDE</code>, multiple templates can be specified,
                          delimited by <code>+</code>, and are processed in order.
                        </p>
                        <pre>[% PROCESS html/header + my/header %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_WRAPPER" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">WRAPPER</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          It's not unusual to find yourself adding common headers and footers to
                          pages or sub-sections within a page. Something like this:
                        </p>
                        <pre>[% INCLUDE section/header
   title = 'Quantum Mechanics'
%]
   Quantum mechanics is a very interesting subject wish 
   should prove easy for the layman to fully comprehend.
[% INCLUDE section/footer %]

[% INCLUDE section/header
   title = 'Desktop Nuclear Fusion for under $50'
%]
   This describes a simple device which generates significant 
   sustainable electrical power from common tap water by process 
   of nuclear fusion.
[% INCLUDE section/footer %]</pre>
                        <p>
                          The individual template components being included might look like these:
                        </p>
                        <p>
                          section/header:
                        </p>
                        <pre>&lt;p&gt;
&lt;h2&gt;[% title %]&lt;/h2&gt;</pre>
                        <p>
                          section/footer:
                        </p>
                        <pre>&lt;/p&gt;</pre>
                        <p>
                          The <code>WRAPPER</code> directive provides a way of simplifying this a
                          little. It encloses a block up to a matching <code>END</code> directive,
                          which is first processed to generate some output. This is then passed to
                          the named template file or <code>BLOCK</code> as the <code>content</code>
                          variable.
                        </p>
                        <pre>[% WRAPPER section
   title = 'Quantum Mechanics'
%]
   Quantum mechanics is a very interesting subject wish 
   should prove easy for the layman to fully comprehend.
[% END %]

[% WRAPPER section
   title = 'Desktop Nuclear Fusion for under $50'
%]
   This describes a simple device which generates significant 
   sustainable electrical power from common tap water by process 
   of nuclear fusion.
[% END %]</pre>
                        <p>
                          The single 'section' template can then be defined as:
                        </p>
                        <pre>&lt;h2&gt;[% title %]&lt;/h2&gt;
&lt;p&gt;
  [% content %]
&lt;/p&gt;</pre>
                        <p>
                          Like other block directives, it can be used in side-effect notation:
                        </p>
                        <pre>[% INSERT legalese.txt WRAPPER big_bold_table %]</pre>
                        <p>
                          It's also possible to specify multiple templates to a
                          <code>WRAPPER</code> directive. The specification order indicates
                          outermost to innermost wrapper templates. For example, given the
                          following template block definitions:
                        </p>
                        <pre>[% BLOCK bold   %]&lt;b&gt;[% content %]&lt;/b&gt;[% END %]
[% BLOCK italic %]&lt;i&gt;[% content %]&lt;/i&gt;[% END %]</pre>
                        <p>
                          the directive
                        </p>
                        <pre>[% WRAPPER bold+italic %]Hello World[% END %]</pre>
                        <p>
                          would generate the following output:
                        </p>
                        <pre>&lt;b&gt;&lt;i&gt;Hello World&lt;/i&gt;&lt;/b&gt;</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_BLOCK" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">BLOCK</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>BLOCK</code>...<code>END</code> construct can be used to define
                          template component blocks which can be processed with the
                          <code>INCLUDE</code>, <code>PROCESS</code> and <code>WRAPPER</code>
                          directives.
                        </p>
                        <pre>[% BLOCK tabrow %]
&lt;tr&gt;
  &lt;td&gt;[% name %]&lt;td&gt;
  &lt;td&gt;[% email %]&lt;/td&gt;
&lt;/tr&gt;
[% END %]

&lt;table&gt;
  [% PROCESS tabrow  name='Fred'  email='fred@nowhere.com' %]
  [% PROCESS tabrow  name='Alan'  email='alan@nowhere.com' %]
&lt;/table&gt;</pre>
                        <p>
                          A <code>BLOCK</code> definition can be used before it is defined, as long
                          as the definition resides in the same file. The block definition itself
                          does not generate any output.
                        </p>
                        <pre>[% PROCESS tmpblk %]

[% BLOCK tmpblk %] This is OK [% END %]</pre>
                        <p>
                          You can use an anonymous <code>BLOCK</code> to capture the output of a
                          template fragment.
                        </p>
                        <pre>[% julius = BLOCK %]
   And Caesar's spirit, ranging for revenge,
   With Ate by his side come hot from hell,
   Shall in these confines with a monarch's voice
   Cry  'Havoc', and let slip the dogs of war;
   That this foul deed shall smell above the earth
   With carrion men, groaning for burial.
[% END %]</pre>
                        <p>
                          Like a named block, it can contain any other template directives which
                          are processed when the block is defined. The output generated by the
                          block is then assigned to the variable <code>julius</code>.
                        </p>
                        <p>
                          Anonymous <code>BLOCK</code>s can also be used to define block macros.
                          The enclosing block is processed each time the macro is called.
                        </p>
                        <pre>[% MACRO locate BLOCK %]
   The [% animal %] sat on the [% place %].
[% END %]

[% locate(animal='cat', place='mat') %]    # The cat sat on the mat
[% locate(animal='dog', place='log') %]    # The dog sat on the log</pre>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Conditional_Processing" onclick="switch_section(this)" title="Click title to show/hide section content.">Conditional Processing</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_IF_UNLESS_ELSIF_ELSE" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">IF / UNLESS / ELSIF / ELSE</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>IF</code> and <code>UNLESS</code> directives can be used to
                          process or ignore a block based on some run-time condition.
                        </p>
                        <pre>[% IF frames %]
   [% INCLUDE frameset %]
[% END %]

[% UNLESS text_mode %]
   [% INCLUDE biglogo %]
[% END %]</pre>
                        <p>
                          Multiple conditions may be joined with <code>ELSIF</code> and/or
                          <code>ELSE</code> blocks.
                        </p>
                        <pre>[% IF age &lt; 10 %]
   Hello [% name %], does your mother know you're 
   using her AOL account?
[% ELSIF age &lt; 18 %]
   Sorry, you're not old enough to enter 
   (and too dumb to lie about your age)
[% ELSE %]
   Welcome [% name %].
[% END %]</pre>
                        <p>
                          The following conditional and boolean operators may be used:
                        </p>
                        <pre>== != &lt; &lt;= &gt; &gt;= &amp;&amp; || ! and or not</pre>
                        <p>
                          Conditions may be arbitrarily complex and are evaluated with the same
                          precedence as in Perl. Parenthesis may be used to explicitly determine
                          evaluation order.
                        </p>
                        <pre># ridiculously contrived complex example
[% IF (name == 'admin' || uid &lt;= 0) &amp;&amp; mode == 'debug' %]
   I'm confused.
[% ELSIF more &gt; less %]
   That's more or less correct.
[% END %]</pre>
                        <p>
                          The <code>and</code>, <code>or</code> and <code>not</code> operator are
                          provided as aliases for <code>&amp;&amp;</code>, <code>||</code> and
                          <code>!</code>, respectively. Unlike Perl, which treats <code>and</code>,
                          <code>or</code> and <code>not</code> as separate, lower-precedence
                          versions of the other operators, the Template Toolkit performs a
                          straightforward substitution of <code>and</code> for
                          <code>&amp;&amp;</code>, and so on. That means that <code>and</code>,
                          <code>or</code> and <code>not</code> have the same operator precedence as
                          <code>&amp;&amp;</code>, <code>||</code> and <code>!</code>.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_SWITCH_CASE" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">SWITCH / CASE</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>SWITCH</code> / <code>CASE</code> construct can be used to
                          perform a multi-way conditional test. The <code>SWITCH</code> directive
                          expects an expression which is first evaluated and then compared against
                          each CASE statement in turn. Each <code>CASE</code> directive should
                          contain a single value or a list of values which should match.
                          <code>CASE</code> may also be left blank or written as <code>[% CASE
                          DEFAULT %]</code> to specify a default match. Only one <code>CASE</code>
                          matches, there is no drop-through between <code>CASE</code> statements.
                        </p>
                        <pre>[% SWITCH myvar %]
[%   CASE value1 %]
       ...
[%   CASE [ value2 value3 ] %]   # multiple values
       ...
[%   CASE myhash.keys %]         # ditto
       ...
[%   CASE %]                     # default
       ...
[% END %]</pre>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Loop_Processing" onclick="switch_section(this)" title="Click title to show/hide section content.">Loop Processing</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_FOREACH" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">FOREACH</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>FOREACH</code> directive will iterate through the items in a
                          list, processing the enclosed block for each one.
                        </p>
                        <pre>my $vars = {
    foo   =&gt; 'Foo',
    items =&gt; [ 'one', 'two', 'three' ],
};

template:</pre>
                        <pre>Things:
[% FOREACH thing = [ foo 'Bar' "$foo Baz" ] %]
   * [% thing %]
[% END %]

Items:
[% FOREACH i IN items %]
   * [% i %]
[% END %]

Stuff:
[% stuff = [ foo "$foo Bar" ] %]
[% FOREACH s IN stuff %]
   * [% s %]
[% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>Things:
  * Foo
  * Bar
  * Foo Baz

Items:
  * one
  * two
  * three

Stuff:
  * Foo
  * Foo Bar</pre>
                        <p>
                          You can use also use <code>IN</code> instead of <code>=</code> if you
                          prefer.
                        </p>
                        <pre>[% FOREACH crook IN government %]</pre>
                        <p>
                          When the <code>FOREACH</code> directive is used without specifying a
                          target variable, any iterated values which are hash references will be
                          automatically imported.
                        </p>
                        <pre>[% userlist = [
    { id =&gt; 'tom',   name =&gt; 'Thomas'  },
    { id =&gt; 'dick',  name =&gt; 'Richard'  },
    { id =&gt; 'larry', name =&gt; 'Lawrence' },
   ]
%]

[% FOREACH user IN userlist %]
   [% user.id %] [% user.name %]
[% END %]</pre>
                        <p>
                          short form:
                        </p>
                        <pre>[% FOREACH userlist %]
   [% id %] [% name %]
[% END %]</pre>
                        <p>
                          Note that this particular usage creates a localised variable context to
                          prevent the imported hash keys from overwriting any existing variables.
                          The imported definitions and any other variables defined in such a
                          <code>FOREACH</code> loop will be lost at the end of the loop, when the
                          previous context and variable values are restored.
                        </p>
                        <p>
                          However, under normal operation, the loop variable remains in scope after
                          the <code>FOREACH</code> loop has ended (caveat: overwriting any variable
                          previously in scope). This is useful as the loop variable is secretly an
                          iterator object (see below) and can be used to analyse the last entry
                          processed by the loop.
                        </p>
                        <p>
                          The <code>FOREACH</code> directive can also be used to iterate through
                          the entries in a hash array. Each entry in the hash is returned in sorted
                          order (based on the key) as a hash array containing 'key' and 'value'
                          items.
                        </p>
                        <pre>[% users = {
     tom   =&gt; 'Thomas',
     dick  =&gt; 'Richard',
     larry =&gt; 'Lawrence',
   }
%]

[% FOREACH u IN users %]
   * [% u.key %] : [% u.value %]
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>* dick : Richard
* larry : Lawrence
* tom : Thomas      </pre>
                        <p>
                          The <code>NEXT</code> directive starts the next iteration in the
                          <code>FOREACH</code> loop.
                        </p>
                        <pre>[% FOREACH user IN userlist %]
   [% NEXT IF user.isguest %]
   Name: [% user.name %]    Email: [% user.email %]
[% END %]</pre>
                        <p>
                          The <code>LAST</code> directive can be used to prematurely exit the loop.
                          <code>BREAK</code> is also provided as an alias for <code>LAST</code>.
                        </p>
                        <pre>[% FOREACH match IN results.nsort('score').reverse %]
   [% LAST IF match.score &lt; 50 %]
   [% match.score %] : [% match.url %]
[% END %]</pre>
                        <p>
                          The <code>FOREACH</code> directive is implemented using the <a href="../modules/Template/Iterator.html">Template::Iterator</a> module. A
                          reference to the iterator object for a <code>FOREACH</code> directive is
                          implicitly available in the <code>loop</code> variable. The following
                          methods can be called on the <code>loop</code> iterator.
                        </p>
                        <pre>size()      number of elements in the list
max()       index number of last element (size - 1)
index()     index of current iteration from 0 to max()
count()     iteration counter from 1 to size() (i.e. index() + 1)
first()     true if the current iteration is the first
last()      true if the current iteration is the last
prev()      return the previous item in the list
next()      return the next item in the list</pre>
                        <p>
                          See <a href="../modules/Template/Iterator.html">Template::Iterator</a> for further details.
                        </p>
                        <p>
                          Example:
                        </p>
                        <pre>[% FOREACH item IN [ 'foo', 'bar', 'baz' ] -%]
   [%- "&lt;ul&gt;\n" IF loop.first %]
   &lt;li&gt;[% loop.count %]/[% loop.size %]: [% item %]
   [%- "&lt;/ul&gt;\n" IF loop.last %]
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>&lt;ul&gt;
&lt;li&gt;1/3: foo
&lt;li&gt;2/3: bar
&lt;li&gt;3/3: baz
&lt;/ul&gt;</pre>
                        <p>
                          Nested loops will work as expected, with the <code>loop</code> variable
                          correctly referencing the innermost loop and being restored to any
                          previous value (i.e. an outer loop) at the end of the loop.
                        </p>
                        <pre>[% FOREACH group IN grouplist;
     # loop =&gt; group iterator
     "Groups:\n" IF loop.first;

     FOREACH user IN group.userlist;
        # loop =&gt; user iterator
        "$loop.count: $user.name\n";
     END;

     # loop =&gt; group iterator
     "End of Groups\n" IF loop.last;
   END 
%]</pre>
                        <p>
                          The <code>iterator</code> plugin can also be used to explicitly create an
                          iterator object. This can be useful within nested loops where you need to
                          keep a reference to the outer iterator within the inner loop. The
                          iterator plugin effectively allows you to create an iterator by a name
                          other than <code>loop</code>. See <a href="../modules/Template/Plugin/Iterator.html">Template::Plugin::Iterator</a> for further details.
                        </p>
                        <pre>[% USE giter = iterator(grouplist) %]

[% FOREACH group IN giter %]
   [% FOREACH user IN group.userlist %]
         user #[% loop.count %] in
         group [% giter.count %] is
         named [% user.name %]
   [% END %]
[% END %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_WHILE" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">WHILE</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>WHILE</code> directive can be used to repeatedly process a
                          template block while a conditional expression evaluates true. The
                          expression may be arbitrarily complex as per <code>IF</code> /
                          <code>UNLESS</code>.
                        </p>
                        <pre>[% WHILE total &lt; 100 %]
   ...
   [% total = calculate_new_total %]
[% END %]</pre>
                        <p>
                          An assignment can be enclosed in parenthesis to evaluate the assigned
                          value.
                        </p>
                        <pre>[% WHILE (user = get_next_user_record) %]
   [% user.name %]
[% END %]</pre>
                        <p>
                          The <code>NEXT</code> directive can be used to start the next iteration
                          of a <code>WHILE</code> loop and <code>BREAK</code> can be used to exit
                          the loop, both as per <code>FOREACH</code>.
                        </p>
                        <p>
                          The Template Toolkit uses a failsafe counter to prevent runaway
                          <code>WHILE</code> loops which would otherwise never terminate. If the
                          loop exceeds 1000 iterations then an <code>undef</code> exception will be
                          thrown, reporting the error:
                        </p>
                        <pre>WHILE loop terminated (&gt; 1000 iterations)</pre>
                        <p>
                          The <code>$Template::Directive::WHILE_MAX</code> variable controls this
                          behaviour and can be set to a higher value if necessary.
                        </p>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Filters_Plugins_Macros_and_Perl" onclick="switch_section(this)" title="Click title to show/hide section content.">Filters, Plugins, Macros and Perl</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_FILTER" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">FILTER</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>FILTER</code> directive can be used to post-process the output
                          of a block. A number of standard filters are provided with the Template
                          Toolkit. The <code>html</code> filter, for example, escapes the '&lt;',
                          '&gt;' and '&amp;' characters to prevent them from being interpreted as
                          HTML tags or entity reference markers.
                        </p>
                        <pre>[% FILTER html %]
   HTML text may have &lt; and &gt; characters embedded
   which you want converted to the correct HTML entities.
[% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>HTML text may have &amp;lt; and &amp;gt; characters embedded
which you want converted to the correct HTML entities.</pre>
                        <p>
                          The <code>FILTER</code> directive can also follow various other non-block
                          directives. For example:
                        </p>
                        <pre>[% INCLUDE mytext FILTER html %]</pre>
                        <p>
                          The <code>|</code> character can also be used as an alias for
                          <code>FILTER</code>.
                        </p>
                        <pre>[% INCLUDE mytext | html %]</pre>
                        <p>
                          Multiple filters can be chained together and will be called in sequence.
                        </p>
                        <pre>[% INCLUDE mytext FILTER html FILTER html_para %]</pre>
                        <p>
                          or
                        </p>
                        <pre>[% INCLUDE mytext | html | html_para %]</pre>
                        <p>
                          Filters come in two flavours, known as 'static' or 'dynamic'. A static
                          filter is a simple subroutine which accepts a text string as the only
                          argument and returns the modified text. The <code>html</code> filter is
                          an example of a static filter, implemented as:
                        </p>
                        <pre>sub html_filter {
    my $text = shift;
    for ($text) {
        s/&amp;/&amp;amp;/g;
        s/&lt;/&amp;lt;/g;
        s/&gt;/&amp;gt;/g;
    }
    return $text;
}</pre>
                        <p>
                          Dynamic filters can accept arguments which are specified when the filter
                          is called from a template. The <code>repeat</code> filter is such an
                          example, accepting a numerical argument which specifies the number of
                          times that the input text should be repeated.
                        </p>
                        <pre>[% FILTER repeat(3) %]blah [% END %]</pre>
                        <p>
                          output:
                        </p>
                        <pre>blah blah blah</pre>
                        <p>
                          These are implemented as filter 'factories'. The factory subroutine is
                          passed a reference to the current <a href="../modules/Template/Context.html">Template::Context</a> object along
                          with any additional arguments specified. It should then return a
                          subroutine reference (e.g. a closure) which implements the filter. The
                          <code>repeat</code> filter factory is implemented like this:
                        </p>
                        <pre>sub repeat_filter_factory {
    my ($context, $iter) = @_;
    $iter = 1 unless defined $iter;

    return sub {
        my $text = shift;
        $text = '' unless defined $text;
        return join('\n', $text) x $iter;
    }
}</pre>
                        <p>
                          The <code>FILTERS</code> option, described in <a href="../manual/Config.html">Template::Manual::Config</a>,
                          allows custom filters to be defined when a Template object is
                          instantiated. The <a
                          href="#method_define_filter">Template::Context#define_filter()</a> method
                          allows further filters to be defined at any time.
                        </p>
                        <p>
                          When using a filter, it is possible to assign an alias to it for further
                          use. This is most useful for dynamic filters that you want to re-use with
                          the same configuration.
                        </p>
                        <pre>[% FILTER echo = repeat(2) %]
Is there anybody out there?
[% END %]

[% FILTER echo %]
Mother, should I build a wall?
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>Is there anybody out there?
Is there anybody out there?</pre>
                        <pre>Mother, should I build a wall?
Mother, should I build a wall?</pre>
                        <p>
                          The <code>FILTER</code> directive automatically quotes the name of the
                          filter. As with <code>INCLUDE</code> et al, you can use a variable to
                          provide the name of the filter, prefixed by <code>$</code>.
                        </p>
                        <pre>[% myfilter = 'html' %]
[% FILTER $myfilter %]      # same as [% FILTER html %]
   ...
[% END %]</pre>
                        <p>
                          A template variable can also be used to define a static filter
                          subroutine. However, the Template Toolkit will automatically call any
                          subroutine bound to a variable and use the value returned. Thus, the
                          above example could be implemented as:
                        </p>
                        <pre>my $vars = {
    myfilter =&gt; sub { return 'html' },
};</pre>
                        <p>
                          template:
                        </p>
                        <pre>[% FILTER $myfilter %]      # same as [% FILTER html %]
   ...
[% END %]</pre>
                        <p>
                          To define a template variable that evaluates to a subroutine reference
                          that can be used by the <code>FILTER</code> directive, you should create
                          a subroutine that, when called automatically by the Template Toolkit,
                          returns another subroutine reference which can then be used to perform
                          the filter operation. Note that only static filters can be implemented in
                          this way.
                        </p>
                        <pre>my $vars = {
    myfilter =&gt; sub { \&amp;my_filter_sub },
};

sub my_filter_sub {
    my $text = shift;
    # do something
    return $text;
}</pre>
                        <p>
                          template:
                        </p>
                        <pre>[% FILTER $myfilter %]
   ...
[% END %]</pre>
                        <p>
                          Alternately, you can bless a subroutine reference into a class (any class
                          will do) to fool the Template Toolkit into thinking it's an object rather
                          than a subroutine. This will then bypass the automatic
                          "call-a-subroutine-to-return-a-value" magic.
                        </p>
                        <pre>my $vars = {
    myfilter =&gt; bless(\&amp;my_filter_sub, 'anything_you_like'),
};</pre>
                        <p>
                          template:
                        </p>
                        <pre>[% FILTER $myfilter %]          
   ...
[% END %]</pre>
                        <p>
                          Filters bound to template variables remain local to the variable context
                          in which they are defined. That is, if you define a filter in a
                          <code>PERL</code> block within a template that is loaded via
                          <code>INCLUDE</code>, then the filter definition will only exist until
                          the end of that template when the stash is delocalised, restoring the
                          previous variable state. If you want to define a filter which persists
                          for the lifetime of the processor, or define additional dynamic filter
                          factories, then you can call the <a
                          href="#method_define_filter">Template::Context#define_filter()</a> method
                          on the current <a href="../modules/Template/Context.html">Template::Context</a> object.
                        </p>
                        <p>
                          See <a href="../manual/Filters.html">Template::Manual::Filters</a> for a complete list of available
                          filters, their descriptions and examples of use.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_USE" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">USE</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>USE</code> directive can be used to load and initialise
                          "plugin" extension modules.
                        </p>
                        <pre>[% USE myplugin %]</pre>
                        <p>
                          A plugin is a regular Perl module that conforms to a particular
                          object-oriented interface, allowing it to be loaded into and used
                          automatically by the Template Toolkit. For details of this interface and
                          information on writing plugins, consult <a href="../modules/Template/Plugin.html">Template::Plugin</a>.
                        </p>
                        <p>
                          A number of standard plugins are included with the Template Toolkit (see
                          below and <a href="../manual/Plugins.html">Template::Manual::Plugins</a>). The names of these standard plugins
                          are case insensitive.
                        </p>
                        <pre>[% USE CGI   %]        # =&gt; Template::Plugin::CGI
[% USE Cgi   %]        # =&gt; Template::Plugin::CGI
[% USE cgi   %]        # =&gt; Template::Plugin::CGI</pre>
                        <p>
                          You can also define further plugins using the <code>PLUGINS</code>
                          option.
                        </p>
                        <pre>my $tt = Template-&gt;new({
    PLUGINS =&gt; {
        foo =&gt; 'My::Plugin::Foo',
        bar =&gt; 'My::Plugin::Bar',
    },
});</pre>
                        <p>
                          The recommended convention is to specify these plugin names in lower
                          case. The Template Toolkit first looks for an exact case-sensitive match
                          and then tries the lower case conversion of the name specified.
                        </p>
                        <pre>[% USE Foo %]      # look for 'Foo' then 'foo'</pre>
                        <p>
                          If you define all your <code>PLUGINS</code> with lower case names then
                          they will be located regardless of how the user specifies the name in the
                          <code>USE</code> directive. If, on the other hand, you define your
                          <code>PLUGINS</code> with upper or mixed case names then the name
                          specified in the <code>USE</code> directive must match the case exactly.
                        </p>
                        <p>
                          If the plugin isn't defined in either the standard plugins
                          (<code>$Template::Plugins::STD_PLUGINS</code>) or via the
                          <code>PLUGINS</code> option, then the <code>PLUGIN_BASE</code> is
                          searched.
                        </p>
                        <p>
                          In this case the plugin name <i>is</i> case-sensitive. It is appended to
                          each of the <code>PLUGIN_BASE</code> module namespaces in turn (default:
                          <code>Template::Plugin</code>) to construct a full module name which it
                          attempts to locate and load. Any periods, '<code>.</code>', in the name
                          will be converted to '<code>::</code>'.
                        </p>
                        <pre>[% USE MyPlugin %]     #  =&gt; Template::Plugin::MyPlugin
[% USE Foo.Bar  %]     #  =&gt; Template::Plugin::Foo::Bar</pre>
                        <p>
                          The <code>LOAD_PERL</code> option (disabled by default) provides a
                          further way by which external Perl modules may be loaded. If a regular
                          Perl module (i.e. not a <code>Template::Plugin::*</code> or other module
                          relative to some <code>PLUGIN_BASE</code>) supports an object-oriented
                          interface and a <code>new()</code> constructor then it can be loaded and
                          instantiated automatically. The following trivial example shows how the
                          IO::File module might be used.
                        </p>
                        <pre>[% USE file = IO.File('/tmp/mydata') %]

[% WHILE (line = file.getline) %]
   &lt;!-- [% line %] --&gt;
[% END %]</pre>
                        <p>
                          Any additional parameters supplied in parenthesis after the plugin name
                          will be also be passed to the <code>new()</code> constructor. A reference
                          to the current <a href="../modules/Template/Context.html">Template::Context</a> object is passed as the first parameter.
                        </p>
                        <pre>[% USE MyPlugin('foo', 123) %]</pre>
                        <p>
                          equivalent to:
                        </p>
                        <pre>Template::Plugin::MyPlugin-&gt;new($context, 'foo', 123);</pre>
                        <p>
                          The only exception to this is when a module is loaded via the
                          <code>LOAD_PERL</code> option. In this case the <code>$context</code>
                          reference is <i>not</i> passed to the <code>new()</code> constructor.
                          This is based on the assumption that the module is a regular Perl module
                          rather than a Template Toolkit plugin so isn't expecting a context
                          reference and wouldn't know what to do with it anyway.
                        </p>
                        <p>
                          Named parameters may also be specified. These are collated into a hash
                          which is passed by reference as the last parameter to the constructor, as
                          per the general code calling interface.
                        </p>
                        <pre>[% USE url('/cgi-bin/foo', mode='submit', debug=1) %]</pre>
                        <p>
                          equivalent to:
                        </p>
                        <pre>Template::Plugin::URL-&gt;new(
    $context, 
    '/cgi-bin/foo'
    { mode =&gt; 'submit', debug =&gt; 1 }
);</pre>
                        <p>
                          The plugin may represent any data type; a simple variable, hash, list or
                          code reference, but in the general case it will be an object reference.
                          Methods can be called on the object (or the relevant members of the
                          specific data type) in the usual way:
                        </p>
                        <pre>[% USE table(mydata, rows=3) %]

[% FOREACH row IN table.rows %]
   &lt;tr&gt;    
   [% FOREACH item IN row %]
    &lt;td&gt;[% item %]&lt;/td&gt;
   [% END %]
   &lt;/tr&gt;
[% END %]</pre>
                        <p>
                          An alternative name may be provided for the plugin by which it can be
                          referenced:
                        </p>
                        <pre>[% USE scores = table(myscores, cols=5) %]

[% FOREACH row IN scores.rows %]
   ...
[% END %]</pre>
                        <p>
                          You can use this approach to create multiple plugin objects with
                          different configurations. This example shows how the <a
                          href="#section_format">Template::Plugin::Format</a> plugin is used to
                          create sub-routines bound to variables for formatting text as per
                          <code>printf()</code>.
                        </p>
                        <pre>[% USE bold = format('&lt;b&gt;%s&lt;/b&gt;') %]
[% USE ital = format('&lt;i&gt;%s&lt;/i&gt;') %]
[% bold('This is bold')   %]
[% ital('This is italic') %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>&lt;b&gt;This is bold&lt;/b&gt;
&lt;i&gt;This is italic&lt;/i&gt;</pre>
                        <p>
                          This next example shows how the <a
                          href="#section_URL">Template::Plugin::URL</a> plugin can be used to build
                          dynamic URLs from a base part and optional query parameters.
                        </p>
                        <pre>[% USE mycgi = URL('/cgi-bin/foo.pl', debug=1) %]
&lt;a href="[% mycgi %]"&gt;...
&lt;a href="[% mycgi(mode='submit') %]"...</pre>
                        <p>
                          Output:
                        </p>
                        <pre>&lt;a href="/cgi-bin/foo.pl?debug=1"&gt;...
&lt;a href="/cgi-bin/foo.pl?mode=submit&amp;debug=1"&gt;...</pre>
                        <p>
                          The <a href="http://search.cpan.org/search?query=CGI&mode=all">Template::Plugin::CGI</a> plugin is
                          an example of one which delegates to another Perl module. In this this
                          case, to Lincoln Stein's <code>CGI</code> module. All of the methods
                          provided by the <code>CGI</code> module are available via the plugin.
                        </p>
                        <pre>[% USE CGI;
   CGI.start_form;
   CGI.checkbox_group( name   = 'colours', 
                       values = [ 'red' 'green' 'blue' ] );
   CGI.popup_menu( name   = 'items', 
                   values = [ 'foo' 'bar' 'baz' ] );
   CGI.end_form 
%]</pre>
                        <p>
                          See <a href="../manual/Plugins.html">Template::Manual::Plugins</a> for more information on the plugins
                          distributed with the toolkit or available from CPAN.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_MACRO" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">MACRO</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>MACRO</code> directive allows you to define a directive or
                          directive block which is then evaluated each time the macro is called.
                        </p>
                        <pre>[% MACRO header INCLUDE header %]</pre>
                        <p>
                          Calling the macro as:
                        </p>
                        <pre>[% header %]</pre>
                        <p>
                          is then equivalent to:
                        </p>
                        <pre>[% INCLUDE header %]</pre>
                        <p>
                          Macros can be passed named parameters when called. These values remain
                          local to the macro.
                        </p>
                        <pre>[% header(title='Hello World') %]  </pre>
                        <p>
                          equivalent to:
                        </p>
                        <pre>[% INCLUDE header title='Hello World' %]</pre>
                        <p>
                          A <code>MACRO</code> definition may include parameter names. Values
                          passed to the macros are then mapped to these local variables. Other
                          named parameters may follow these.
                        </p>
                        <pre>[% MACRO header(title) INCLUDE header %]
[% header('Hello World') %]
[% header('Hello World', bgcol='#123456') %]</pre>
                        <p>
                          equivalent to:
                        </p>
                        <pre>[% INCLUDE header title='Hello World' %]
[% INCLUDE header title='Hello World' bgcol='#123456' %]</pre>
                        <p>
                          Here's another example, defining a macro for display numbers in
                          comma-delimited groups of 3, using the chunk and join virtual method.
                        </p>
                        <pre>[% MACRO number(n) GET n.chunk(-3).join(',') %]
[% number(1234567) %]    # 1,234,567</pre>
                        <p>
                          A <code>MACRO</code> may precede any directive and must conform to the
                          structure of the directive.
                        </p>
                        <pre>[% MACRO header IF frames %]
   [% INCLUDE frames/header %]
[% ELSE %]
   [% INCLUDE header %]
[% END %]

[% header %]</pre>
                        <p>
                          A <code>MACRO</code> may also be defined as an anonymous
                          <code>BLOCK</code>. The block will be evaluated each time the macro is
                          called.
                        </p>
                        <pre>[% MACRO header BLOCK %]
   ...content...
[% END %]

[% header %]</pre>
                        <p>
                          If you've got the <code>EVAL_PERL</code> option set, then you can even
                          define a <code>MACRO</code> as a <code>PERL</code> block (see below):
                        </p>
                        <pre>[% MACRO triple(n) PERL %]
     my $n = $stash-&gt;get('n');
     print $n * 3;
[% END -%]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_PERL" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">PERL</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          (for the advanced reader)
                        </p>
                        <p>
                          The <code>PERL</code> directive is used to mark the start of a block
                          which contains Perl code for evaluation. The <code>EVAL_PERL</code>
                          option must be enabled for Perl code to be evaluated or a
                          <code>perl</code> exception will be thrown with the message
                          '<code>EVAL_PERL not set</code>'.
                        </p>
                        <p>
                          Perl code is evaluated in the <code>Template::Perl</code> package. The
                          <code>$context</code> package variable contains a reference to the
                          current <a href="../modules/Template/Context.html">Template::Context</a> object. This can be used to access the
                          functionality of the Template Toolkit to process other templates, load
                          plugins, filters, etc. See <a href="../modules/Template/Context.html">Template::Context</a> for further details.
                        </p>
                        <pre>[% PERL %]
   print $context-&gt;include('myfile');
[% END %]</pre>
                        <p>
                          The <a href="#section_$stash">$stash</a> variable contains a reference to
                          the top-level stash object which manages template variables. Through
                          this, variable values can be retrieved and updated. See <a href="../modules/Template/Stash.html">Template::Stash</a> for further
                          details.
                        </p>
                        <pre>[% PERL %]
   $stash-&gt;set(foo =&gt; 'bar');
   print "foo value: ", $stash-&gt;get('foo');
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>foo value: bar</pre>
                        <p>
                          Output is generated from the <code>PERL</code> block by calling
                          <code>print()</code>. Note that the <code>Template::Perl::PERLOUT</code>
                          handle is selected (tied to an output buffer) instead of
                          <code>STDOUT</code>.
                        </p>
                        <pre>[% PERL %]
   print "foo\n";                           # OK
   print PERLOUT "bar\n";                   # OK, same as above
   print Template::Perl::PERLOUT "baz\n";   # OK, same as above
   print STDOUT "qux\n";                    # WRONG!
[% END %]</pre>
                        <p>
                          The <code>PERL</code> block may contain other template directives. These
                          are processed before the Perl code is evaluated.
                        </p>
                        <pre>[% name = 'Fred Smith' %]

[% PERL %]
   print "[% name %]\n";
[% END %]</pre>
                        <p>
                          Thus, the Perl code in the above example is evaluated as:
                        </p>
                        <pre>print "Fred Smith\n";</pre>
                        <p>
                          Exceptions may be thrown from within <code>PERL</code> blocks using
                          <code>die()</code>. They will be correctly caught by enclosing
                          <code>TRY</code> blocks.
                        </p>
                        <pre>[% TRY %]
   [% PERL %]
      die "nothing to live for\n";
   [% END %]
[% CATCH %]
   error: [% error.info %]
[% END %]</pre>
                        <p>
                          output: error: nothing to live for
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_RAWPERL" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">RAWPERL</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          (for the very advanced reader)
                        </p>
                        <p>
                          The Template Toolkit parser reads a source template and generates the
                          text of a Perl subroutine as output. It then uses <code>eval()</code> to
                          evaluate it into a subroutine reference. This subroutine is then called
                          to process the template, passing a reference to the current <a href="../modules/Template/Context.html">Template::Context</a> object through
                          which the functionality of the Template Toolkit can be accessed. The
                          subroutine reference can be cached, allowing the template to be processed
                          repeatedly without requiring any further parsing.
                        </p>
                        <p>
                          For example, a template such as:
                        </p>
                        <pre>[% PROCESS header %]
The [% animal %] sat on the [% location %]
[% PROCESS footer %]</pre>
                        <p>
                          is converted into the following Perl subroutine definition:
                        </p>
                        <pre>sub {
    my $context = shift;
    my $stash   = $context-&gt;stash;
    my $output  = '';
    my $error;

    eval { BLOCK: {
        $output .=  $context-&gt;process('header');
        $output .=  "The ";
        $output .=  $stash-&gt;get('animal');
        $output .=  " sat on the ";
        $output .=  $stash-&gt;get('location');
        $output .=  $context-&gt;process('footer');
        $output .=  "\n";
    } };
    if ($@) {
        $error = $context-&gt;catch($@, \$output);
        die $error unless $error-&gt;type eq 'return';
    }

    return $output;
}</pre>
                        <p>
                          To examine the Perl code generated, such as in the above example, set the
                          <code>$Template::Parser::DEBUG</code> package variable to any true value.
                          You can also set the <code>$Template::Directive::PRETTY</code> variable
                          true to have the code formatted in a readable manner for human
                          consumption. The source code for each generated template subroutine will
                          be printed to <code>STDERR</code> on compilation (i.e. the first time a
                          template is used).
                        </p>
                        <pre>$Template::Parser::DEBUG = 1;
$Template::Directive::PRETTY = 1;

$template-&gt;process($file, $vars)
    || die $template-&gt;error(), "\n";</pre>
                        <p>
                          The <code>PERL</code> ... <code>END</code> construct allows Perl code to
                          be embedded into a template when the <code>EVAL_PERL</code> option is
                          set. It is evaluated at "runtime" using <code>eval()</code> each time the
                          template subroutine is called. This is inherently flexible, but not as
                          efficient as it could be, especially in a persistent server environment
                          where a template may be processed many times.
                        </p>
                        <p>
                          The <code>RAWPERL</code> directive allows you to write Perl code that is
                          integrated directly into the generated Perl subroutine text. It is
                          evaluated once at compile time and is stored in cached form as part of
                          the compiled template subroutine. This makes <code>RAWPERL</code> blocks
                          more efficient than <code>PERL</code> blocks.
                        </p>
                        <p>
                          The downside is that you must code much closer to the metal. For example,
                          in a <code>PERL</code> block you can call <a
                          href="#method_print">print()</a> to generate some output.
                          <code>RAWPERL</code> blocks don't afford such luxury. The code is
                          inserted directly into the generated subroutine text and should conform
                          to the convention of appending to the <code>$output</code> variable.
                        </p>
                        <pre>[% PROCESS  header %]

[% RAWPERL %]
   $output .= "Some output\n";
   ...
   $output .= "Some more output\n";
[% END %]</pre>
                        <p>
                          The critical section of the generated subroutine for this example would
                          then look something like:
                        </p>
                        <pre>...
eval { BLOCK: {
    $output .=  $context-&gt;process('header');
    $output .=  "\n";
    $output .= "Some output\n";
    ...
    $output .= "Some more output\n";
    $output .=  "\n";
} };
...</pre>
                        <p>
                          As with <code>PERL</code> blocks, the <a
                          href="#section_$context">Template::Context</a> and <a
                          href="#section_$stash">Template::Stash</a> references are pre-defined and
                          available for use within <code>RAWPERL</code> code.
                        </p>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Exception_Handling_and_Flow_Control" onclick="switch_section(this)" title="Click title to show/hide section content.">Exception Handling and Flow Control</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_TRY_THROW_CATCH_FINAL" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">TRY / THROW / CATCH / FINAL</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          (more advanced material)
                        </p>
                        <p>
                          The Template Toolkit supports fully functional, nested exception
                          handling. The <code>TRY</code> directive introduces an exception handling
                          scope which continues until the matching <code>END</code> directive. Any
                          errors that occur within that block will be caught and can be handled by
                          one of the <code>CATCH</code> blocks defined.
                        </p>
                        <pre>[% TRY %]
   ...blah...blah...
   [% CALL somecode %]
   ...etc...
   [% INCLUDE someblock %]
   ...and so on...
[% CATCH %]
   An error occurred!
[% END %]</pre>
                        <p>
                          Errors are raised as exceptions (objects of the <a href="../modules/Template/Exception.html">Template::Exception</a> class)
                          which contain two fields: <code>type</code> and <code>info</code>. The
                          exception <code>type</code> is used to indicate the kind of error that
                          occurred. It is a simple text string which can contain letters, numbers,
                          '<code>_</code>' or '<code>.</code>'. The <code>info</code> field
                          contains an error message indicating what actually went wrong. Within a
                          catch block, the exception object is aliased to the <code>error</code>
                          variable. You can access the <code>type</code> and <code>info</code>
                          fields directly.
                        </p>
                        <pre>[% mydsn = 'dbi:MySQL:foobar' %]
...

[% TRY %]
   [% USE DBI(mydsn) %]
[% CATCH %]
   ERROR! Type: [% error.type %]
          Info: [% error.info %]
[% END %]</pre>
                        <p>
                          output (assuming a non-existant database called '<code>foobar</code>'):
                        </p>
                        <pre>ERROR!  Type: DBI
        Info: Unknown database "foobar"</pre>
                        <p>
                          The <code>error</code> variable can also be specified by itself and will
                          return a string of the form "<code>$type error - $info</code>".
                        </p>
                        <pre>...
[% CATCH %]
ERROR: [% error %]
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>ERROR: DBI error - Unknown database "foobar"</pre>
                        <p>
                          Each <code>CATCH</code> block may be specified with a particular
                          exception type denoting the kind of error that it should catch. Multiple
                          <code>CATCH</code> blocks can be provided to handle different types of
                          exception that may be thrown in the <code>TRY</code> block. A
                          <code>CATCH</code> block specified without any type, as in the previous
                          example, is a default handler which will catch any otherwise uncaught
                          exceptions. This can also be specified as <code>[% CATCH DEFAULT
                          %]</code>.
                        </p>
                        <pre>[% TRY %]
   [% INCLUDE myfile %]
   [% USE DBI(mydsn) %]
   [% CALL somecode %]
[% CATCH file %]
   File Error! [% error.info %]
[% CATCH DBI %]
   [% INCLUDE database/error.html %]
[% CATCH %]
   [% error %]
[% END %]</pre>
                        <p>
                          Remember that you can specify multiple directives within a single tag,
                          each delimited by '<code>;</code>'. So the above example can be written
                          more concisely as:
                        </p>
                        <pre>[% TRY;
       INCLUDE myfile;
       USE DBI(mydsn);
       CALL somecode;
   CATCH file;
       "File Error! $error.info";
   CATCH DBI;
       INCLUDE database/error.html;
   CATCH;
       error;
   END 
%]</pre>
                        <p>
                          The <code>DBI</code> plugin throws exceptions of the <code>DBI</code>
                          type (in case that wasn't already obvious). The other specific exception
                          caught here is of the <code>file</code> type.
                        </p>
                        <p>
                          A <code>file</code> exception is automatically thrown by the Template
                          Toolkit when it can't find a file, or fails to load, parse or process a
                          file that has been requested by an <code>INCLUDE</code>,
                          <code>PROCESS</code>, <code>INSERT</code> or <code>WRAPPER</code>
                          directive. If <code>myfile</code> can't be found in the example above,
                          the <code>[% INCLUDE myfile %]</code> directive will raise a
                          <code>file</code> exception which is then caught by the <code>[% CATCH
                          file %]</code> block. The output generated would be:
                        </p>
                        <pre>File Error! myfile: not found</pre>
                        <p>
                          Note that the <code>DEFAULT</code> option (disabled by default) allows
                          you to specify a default file to be used any time a template file can't
                          be found. This will prevent file exceptions from ever being raised when a
                          non-existant file is requested (unless, of course, the
                          <code>DEFAULT</code> file your specify doesn't exist). Errors encountered
                          once the file has been found (i.e. read error, parse error) will be
                          raised as file exceptions as per usual.
                        </p>
                        <p>
                          Uncaught exceptions (i.e. if the <code>TRY</code> block doesn't have a
                          type specific or default <code>CATCH</code> handler) may be caught by
                          enclosing <code>TRY</code> blocks which can be nested indefinitely across
                          multiple templates. If the error isn't caught at any level then
                          processing will stop and the Template <a
                          href="#method_process">Template#process()</a> method will return a false
                          value to the caller. The relevant <a href="../modules/Template/Exception.html">Template::Exception</a> object can
                          be retrieved by calling the <a href="#method_error">Template#error()</a>
                          method.
                        </p>
                        <pre>[% TRY %]
   ...
   [% TRY %]
      [% INCLUDE $user.header %]
   [% CATCH file %]
      [% INCLUDE header %]
   [% END %]
   ...
[% CATCH DBI %]
   [% INCLUDE database/error.html %]
[% END %]</pre>
                        <p>
                          In this example, the inner <code>TRY</code> block is used to ensure that
                          the first <code>INCLUDE</code> directive works as expected. We're using a
                          variable to provide the name of the template we want to include,
                          <code>user.header</code>, and it's possible this contains the name of a
                          non-existant template, or perhaps one containing invalid template
                          directives. If the <code>INCLUDE</code> fails with a <code>file</code>
                          error then we <code>CATCH</code> it in the inner block and
                          <code>INCLUDE</code> the default <code>header</code> file instead. Any
                          <code>DBI</code> errors that occur within the scope of the outer
                          <code>TRY</code> block will be caught in the relevant <code>CATCH</code>
                          block, causing the <code>database/error.html</code> template to be
                          processed. Note that included templates inherit all currently defined
                          template variable so these error files can quite happily access the
                          &lt;error&gt; variable to retrieve information about the currently caught
                          exception. For example, the <code>database/error.html</code> template
                          might look like this:
                        </p>
                        <pre>&lt;h2&gt;Database Error&lt;/h2&gt;
A database error has occurred: [% error.info %]</pre>
                        <p>
                          You can also specify a <code>FINAL</code> block. This is always processed
                          regardless of the outcome of the <code>TRY</code> and/or
                          <code>CATCH</code> blocks. If an exception is uncaught then the
                          <code>FINAL</code> block is processed before jumping to the enclosing
                          block or returning to the caller.
                        </p>
                        <pre>[% TRY %]
   ...
[% CATCH this %] 
   ...
[% CATCH that %] 
   ...
[% FINAL %]
   All done!
[% END %]</pre>
                        <p>
                          The output from the <code>TRY</code> block is left intact up to the point
                          where an exception occurs. For example, this template:
                        </p>
                        <pre>[% TRY %]
   This gets printed 
   [% THROW food 'carrots' %]
   This doesn't
[% CATCH food %]
   culinary delights: [% error.info %]
[% END %]    </pre>
                        <p>
                          generates the following output:
                        </p>
                        <pre>This gets printed
culinary delights: carrots</pre>
                        <p>
                          The <code>CLEAR</code> directive can be used in a <code>CATCH</code> or
                          <code>FINAL</code> block to clear any output created in the
                          <code>TRY</code> block.
                        </p>
                        <pre>[% TRY %]
   This gets printed 
   [% THROW food 'carrots' %]
   This doesn't
[% CATCH food %]
   [% CLEAR %]
   culinary delights: [% error.info %]
[% END %]    </pre>
                        <p>
                          Output:
                        </p>
                        <pre>culinary delights: carrots</pre>
                        <p>
                          Exception types are hierarchical, with each level being separated by the
                          familiar dot operator. A <code>DBI.connect</code> exception is a more
                          specific kind of <code>DBI</code> error. Similarly, an
                          <code>example.error.barf</code> is a more specific kind of
                          <code>example.error</code> type which itself is also a
                          <code>example</code> error.
                        </p>
                        <p>
                          A <code>CATCH</code> handler that specifies a general exception type
                          (such as <code>DBI</code> or <code>example.error</code>) will also catch
                          more specific types that have the same prefix as long as a more specific
                          handler isn't defined. Note that the order in which <code>CATCH</code>
                          handlers are defined is irrelevant; a more specific handler will always
                          catch an exception in preference to a more generic or default one.
                        </p>
                        <pre>[% TRY %]
   ...
[% CATCH DBI ;
     INCLUDE database/error.html ;
   CATCH DBI.connect ;
     INCLUDE database/connect.html ;
   CATCH ; 
     INCLUDE error.html ;
   END
%]</pre>
                        <p>
                          In this example, a <code>DBI.connect</code> error has it's own handler, a
                          more general <code>DBI</code> block is used for all other
                          <code>DBI</code> or <code>DBI.*</code> errors and a default handler
                          catches everything else.
                        </p>
                        <p>
                          Exceptions can be raised in a template using the <code>THROW</code>
                          directive. The first parameter is the exception type which doesn't need
                          to be quoted (but can be, it's the same as <code>INCLUDE</code>) followed
                          by the relevant error message which can be any regular value such as a
                          quoted string, variable, etc.
                        </p>
                        <pre>[% THROW food "Missing ingredients: $recipe.error" %]
[% THROW user.login 'no user id: please login' %]
[% THROW $myerror.type "My Error: $myerror.info" %]</pre>
                        <p>
                          It's also possible to specify additional positional or named parameters
                          to the <code>THROW</code> directive if you want to pass more than just a
                          simple message back as the error info field.
                        </p>
                        <pre>[% THROW food 'eggs' 'flour' msg='Missing Ingredients' %]</pre>
                        <p>
                          In this case, the error <code>info</code> field will be a hash array
                          containing the named arguments and an <code>args</code> item which
                          contains a list of the positional arguments.
                        </p>
                        <pre>type =&gt; 'food',
info =&gt; {
    msg  =&gt; 'Missing Ingredients',
    args =&gt; ['eggs', 'flour'],
}</pre>
                        <p>
                          In addition to specifying individual positional arguments as <code>[%
                          error.info.args.n %]</code>, the <code>info</code> hash contains keys
                          directly pointing to the positional arguments, as a convenient shortcut.
                        </p>
                        <pre>[% error.info.0 %]   # same as [% error.info.args.0 %]</pre>
                        <p>
                          Exceptions can also be thrown from Perl code which you've bound to
                          template variables, or defined as a plugin or other extension. To raise
                          an exception, call <code>die()</code> passing a reference to a <a
                          href="../modules/Template/Exception.html">Template::Exception</a>
                          object as the argument. This will then be caught by any enclosing
                          <code>TRY</code> blocks from where the code was called.
                        </p>
                        <pre>use Template::Exception;
...
my $vars = {
    foo =&gt; sub {
        # ... do something ...
        die Template::Exception-&gt;new('myerr.naughty',
                                     'Bad, bad error');
    },
};</pre>
                        <p>
                          Template:
                        </p>
                        <pre>[% TRY %]
   [% foo %]
[% CATCH myerr ;
     "Error: $error" ;
   END
%]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>Error: myerr.naughty error - Bad, bad error</pre>
                        <p>
                          The <code>info</code> field can also be a reference to another object or
                          data structure, if required.
                        </p>
                        <pre>die Template::Exception-&gt;new('myerror', { 
    module =&gt; 'foo.pl', 
    errors =&gt; [ 'bad permissions', 'naughty boy' ],
});</pre>
                        <p>
                          Later, in a template:
                        </p>
                        <pre>[% TRY %]
   ...
[% CATCH myerror %]
   [% error.info.errors.size or 'no';
      error.info.errors.size == 1 ? ' error' : ' errors' %]
   in [% error.info.module %]: 
      [% error.info.errors.join(', ') %].
[% END %]</pre>
                        <p>
                          Generating the output:
                        </p>
                        <pre>2 errors in foo.pl:
   bad permissions, naughty boy.</pre>
                        <p>
                          You can also call <code>die()</code> with a single string, as is common
                          in much existing Perl code. This will automatically be converted to an
                          exception of the '<code>undef</code>' type (that's the literal string
                          '<code>undef</code>', not the undefined value). If the string isn't
                          terminated with a newline then Perl will append the familiar <code>" at
                          $file line $line"</code> message.
                        </p>
                        <pre>sub foo {
    # ... do something ...
    die "I'm sorry, Dave, I can't do that\n";
}</pre>
                        <p>
                          If you're writing a plugin, or some extension code that has the current
                          <a href="../modules/Template/Context.html">Template::Context</a> in
                          scope (you can safely skip this section if this means nothing to you)
                          then you can also raise an exception by calling the context <a
                          href="#method_throw">Template::Context#throw()</a> method. You can pass
                          it an <a href="../modules/Template/Exception.html">Template::Exception</a> object reference, a pair of <code>($type,
                          $info)</code> parameters or just an <code>$info</code> string to create
                          an exception of '<code>undef</code>' type.
                        </p>
                        <pre>$context-&gt;throw($e);            # exception object
$context-&gt;throw('Denied');      # 'undef' type
$context-&gt;throw('user.passwd', 'Bad Password');</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_NEXT" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">NEXT</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>NEXT</code> directive can be used to start the next iteration
                          of a <code>FOREACH</code> or <code>WHILE</code> loop.
                        </p>
                        <pre>[% FOREACH user IN users %]
   [% NEXT IF user.isguest %]
   Name: [% user.name %]    Email: [% user.email %]
[% END %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_LAST" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">LAST</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>LAST</code> directive can be used to prematurely exit a
                          <code>FOREACH</code> or <code>WHILE</code> loop.
                        </p>
                        <pre>[% FOREACH user IN users %]
   Name: [% user.name %]    Email: [% user.email %]
   [% LAST IF some.condition %]
[% END %]</pre>
                        <p>
                          <code>BREAK</code> can also be used as an alias for <code>LAST</code>.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_RETURN" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">RETURN</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>RETURN</code> directive can be used to stop processing the
                          current template and return to the template from which it was called,
                          resuming processing at the point immediately after the
                          <code>INCLUDE</code>, <code>PROCESS</code> or <code>WRAPPER</code>
                          directive. If there is no enclosing template then the Template <a
                          href="#method_process">Template#process()</a> method will return to the
                          calling code with a true value.
                        </p>
                        <pre>Before
[% INCLUDE half_wit %]
After

[% BLOCK half_wit %]
This is just half...
[% RETURN %]
...a complete block
[% END %]</pre>
                        <p>
                          Output:
                        </p>
                        <pre>Before
This is just half...
After</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_STOP" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">STOP</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>STOP</code> directive can be used to indicate that the
                          processor should stop gracefully without processing any more of the
                          template document. This is a planned stop and the Template <a
                          href="#method_process">Template#process()</a> method will return a
                          <b>true</b> value to the caller. This indicates that the template was
                          processed successfully according to the directives within it.
                        </p>
                        <pre>[% IF something.terrible.happened %]
   [% INCLUDE fatal/error.html %]
   [% STOP %]
[% END %]

[% TRY %]
   [% USE DBI(mydsn) %]
   ...
[% CATCH DBI.connect %]
   &lt;h1&gt;Cannot connect to the database: [% error.info %]&lt;/h1&gt;
   &lt;p&gt;
     We apologise for the inconvenience.
   &lt;/p&gt;
   [% INCLUDE footer %]
   [% STOP %]
[% END %]</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_CLEAR" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">CLEAR</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>CLEAR</code> directive can be used to clear the output buffer
                          for the current enclosing block. It is most commonly used to clear the
                          output generated from a <code>TRY</code> block up to the point where the
                          error occurred.
                        </p>
                        <pre>[% TRY %]
   blah blah blah            # this is normally left intact
   [% THROW some 'error' %]  # up to the point of error
   ...
[% CATCH %]
   [% CLEAR %]               # clear the TRY output
   [% error %]               # print error string
[% END %]</pre>
                  </div>
                </div>
              </div>
            </div>
            <div class="section">
              <div class="head">
                <h1 id="Miscellaneous" onclick="switch_section(this)" title="Click title to show/hide section content.">Miscellaneous</h1>
                <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
              </div>
              <div class="body">
                <div class="subsection">
                  <div class="head">
                    <h2 id="section_META" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">META</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>META</code> directive allows simple metadata items to be
                          defined within a template. These are evaluated when the template is
                          parsed and as such may only contain simple values (e.g. it's not possible
                          to interpolate other variables values into <code>META</code> variables).
                        </p>
                        <pre>[% META
   title   = 'The Cat in the Hat'
   author  = 'Dr. Seuss'
   version = 1.23 
%]</pre>
                        <p>
                          The <code>template</code> variable contains a reference to the main
                          template being processed. These metadata items may be retrieved as
                          attributes of the template.
                        </p>
                        <pre>&lt;h1&gt;[% template.title %]&lt;/h1&gt;
&lt;h2&gt;[% template.author %]&lt;/h2&gt;</pre>
                        <p>
                          The <code>name</code> and <code>modtime</code> metadata items are
                          automatically defined for each template to contain its name and
                          modification time in seconds since the epoch.
                        </p>
                        <pre>[% USE date %]              # use Date plugin to format time
...
[% template.name %] last modified
at [% date.format(template.modtime) %]</pre>
                        <p>
                          The <code>PRE_PROCESS</code> and <code>POST_PROCESS</code> options allow
                          common headers and footers to be added to all templates. The
                          <code>template</code> reference is correctly defined when these templates
                          are processed, allowing headers and footers to reference metadata items
                          from the main template.
                        </p>
                        <pre>$template = Template-&gt;new({
    PRE_PROCESS  =&gt; 'header',
    POST_PROCESS =&gt; 'footer',
});

$template-&gt;process('cat_in_hat');</pre>
                        <p>
                          header:
                        </p>
                        <pre>&lt;html&gt;
  &lt;head&gt;
    &lt;title&gt;[% template.title %]&lt;/title&gt;
  &lt;/head&gt;
  &lt;body&gt;</pre>
                        <p>
                          cat_in_hat:
                        </p>
                        <pre>[% META
     title   = 'The Cat in the Hat'
     author  = 'Dr. Seuss'
     version = 1.23 
     year    = 2000
%]

    The cat in the hat sat on the mat.</pre>
                        <p>
                          footer:
                        </p>
                        <pre>    &lt;hr&gt;
    &amp;copy; [% template.year %] [% template.author %]
  &lt;/body&gt;
&lt;/html&gt;</pre>
                        <p>
                          The output generated from the above example is:
                        </p>
                        <pre>&lt;html&gt;
  &lt;head&gt;
    &lt;title&gt;The Cat in the Hat&lt;/title&gt;
  &lt;/head&gt;
  &lt;body&gt;
    The cat in the hat sat on the mat.
    &lt;hr&gt;
    &amp;copy; 2000 Dr. Seuss
  &lt;/body&gt;
&lt;/html&gt;</pre>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_TAGS" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">TAGS</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>TAGS</code> directive can be used to set the
                          <code>START_TAG</code> and <code>END_TAG</code> values on a per-template
                          file basis.
                        </p>
                        <pre>[% TAGS &lt;+ +&gt; %]

&lt;+ INCLUDE header +&gt;</pre>
                        <p>
                          The TAGS directive may also be used to set a named <code>TAG_STYLE</code>
                        </p>
                        <pre>[% TAGS html %]
&lt;!-- INCLUDE header --&gt;</pre>
                        <p>
                          See the <a href="#section_TAGS">Template::Manual::Config#TAGS</a> and <a
                          href="#section_TAG_STYLE">Template::Manual::Config#TAG_STYLE</a>
                          configuration options for further details.
                        </p>
                  </div>
                </div>    <div class="subsection">
                  <div class="head">
                    <h2 id="section_DEBUG" onclick="switch_subsection(this)" title="Click title to show/hide sub-section content.">DEBUG</h2>
                    <a href="#body" class="top" title="Back up to the top of the page" >Top</a>
                  </div>
                  <div class="body">
                    <p>
                          The <code>DEBUG</code> directive can be used to enable or disable
                          directive debug messages within a template. The <code>DEBUG</code>
                          configuration option must be set to include <code>DEBUG_DIRS</code> for
                          the <code>DEBUG</code> directives to have any effect. If
                          <code>DEBUG_DIRS</code> is not set then the parser will automatically
                          ignore and remove any <code>DEBUG</code> directives.
                        </p>
                        <p>
                          The <code>DEBUG</code> directive can be used with an <code>on</code> or
                          <code>off</code> parameter to enable or disable directive debugging
                          messages from that point forward. When enabled, the output of each
                          directive in the generated output will be prefixed by a comment indicate
                          the file, line and original directive text.
                        </p>
                        <pre>[% DEBUG on %]
directive debugging is on (assuming DEBUG option is set true)
[% DEBUG off %]
directive debugging is off</pre>
                        <p>
                          The <code>format</code> parameter can be used to change the format of the
                          debugging message.
                        </p>
                        <pre>[% DEBUG format '&lt;!-- $file line $line : [% $text %] --&gt;' %]</pre>
                  </div>
                </div>
              </div>
            </div>
            
            </div></div>
          <br class="clear" />
          <div class="pageinfo">
            /manual/Directives.html last modified 10:57:39 31-May-2007
          </div>
        </div>
        
        <div id="footer">
          <a href="http://opensource.org/" class="osi"></a>
          <div class="controls">
          <div class="pager">
            <a href="../manual/Syntax.html" title="Template::Manual::Syntax" class="go back">Back<span class="about"><h4>Template::Manual::Syntax</h4></span></a>
            <a href="../manual/index.html" title="Template::Manual" class="go up">Up<span class="about"><h4>Template::Manual</h4></span></a>
            <a href="../manual/Variables.html" title="Template::Manual::Variables" class="go next">Next<span class="about"><h4>Template::Manual::Variables</h4></span></a>
          </div>
          </div>
          <div class="copyright">
            Copyright &copy; 1996-2007 <a href="http://wardley.org/">Andy Wardley</a>.  All Rights Reserved.
          </div>
          <div class="licence">
            The <a href="http://template-toolkit.org/">Template Toolkit</a> is <a href="http://opensource.org/">Open Source</a> software.
            You can redistribute and/or modify it under the terms of the <a href="http://www.opensource.org/licenses/gpl-license.php">GNU Public Licence</a>
            or the <a href="http://www.opensource.org/licenses/artistic-license.php">Perl Artistic Licence</a>.
          </div>
        </div>
        <div id="palette">
          <ul>
            <li class="first"><a href="#" class="blue" onclick="set_style('Clear Blue')"></a></li>
            <li><a href="#" class="orange" onclick="set_style('Clear Orange')"></a></li>
            <li><a href="#" class="green" onclick="set_style('Clear Green')"></a></li>
            <li><a href="#" class="purple" onclick="set_style('Clear Purple')"></a></li>
            <li><a href="#" class="grey" onclick="set_style('Clear Grey')"></a></li>
          </ul>
        </div>
    </div>  </body>
</html>