Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
HTML::Template::PerlInUseraContributed Perl DoHTML::Template::PerlInterface(3)

       HTML::Template::PerlInterface - perl interface of HTML::Template::Pro

       This help is only on perl interface of HTML::Template::Pro.  For	syntax
       of html template	files you should see "SYNOPSIS"	in

       First you make a	template - this	is just	a normal HTML file with	a few
       extra tags, the simplest	being <TMPL_VAR>

       For example, test.tmpl:

	 <head><title>Test Template</title>
	 My Home Directory is <TMPL_VAR	NAME=HOME>
	 My Path is set	to <TMPL_VAR NAME=PATH>

       See HTML::Template::SYNTAX for their syntax.

       Now create a small CGI program:

	 #!/usr/bin/perl -w
	 use HTML::Template::Pro;

	 # open	the html template
	 my $template =	HTML::Template::Pro->new(
	       filename	=> 'test.tmpl',
	       case_sensitive=>	1);

	 # fill	in some	parameters
	 $template->param(HOME => $ENV{HOME});
	 $template->param(PATH => $ENV{PATH});

	 # send	the obligatory Content-Type and	print the template output
	 print "Content-Type: text/html\n\n";

	 # print output

	 # this	would also work.
	 # print $template->output();

	 # this	would also work. It is faster,
	 # but (WARNING!) not compatible with original HTML::Template.
	 # $template->output();

       If all is well in the universe this should show something like this in
       your browser when visiting the CGI:

	 My Home Directory is /home/some/directory
	 My Path is set	to /bin;/usr/bin

       For the best performance	it is recommended to use case_sensitive=>1 in
       new() and print_to=>\*STDOUT in output().

       Note that (HTML::Template::Pro version 0.90+) output(), called in void
       context,	also prints to stdout using built-in htmltmplpro C library
       calls, so the last call "$template->output();" might be,	in fact, the
       fastest way to call output().

       IMPORTANT NOTE: you can safely write

	 my $template =	HTML::Template->new( ... options ...)
	       or even
	 my $template =	HTML::Template::Expr->new( ... options ...)

       with HTML::Template::Pro, because in absence of original	HTML::Template
       and HTML::Template::Expr	HTML::Template::Pro intercepts their calls.

       You can also use	all three modules and safely mix their calls
       (benchmarking may be the	only reason for	it).  In case you want to mix
       calls to	HTML::Template::Expr and HTML::Template::Pro, the only proper
       usage of	their load is

       use HTML::Template; use HTML::Template::Expr; use HTML::Template::Pro;

       Of course, if you don't plan to mix them	(in most cases)	it is enough
       to simply write

       use HTML::Template::Pro;

       Simply use HTML::Template::Pro, it supports all functions of

       HTML::Template::Pro is a	fast C/perl+XS implementation of
       HTML::Template and HTML::Template::Expr.	 See HTML::Template::Pro for

       It fully	supports template language of HTML::Template as	described in


       "This module attempts to	make using HTML	templates simple and natural.
       It extends standard HTML	with a few new HTML-esque tags - <TMPL_VAR>,
       The file	written	with HTML and these new	tags is	called a template.  It
       is usually saved	separate from your script - possibly even created by
       someone else!  Using this module	you fill in the	values for the
       variables, loops	and branches declared in the template.	This allows
       you to separate design -	the HTML - from	the data, which	you generate
       in the Perl script."

       Here is described a perl	interface of HTML::Template::Pro and
       HTML::Template +	HTML::Template::Expr.  See DISTINCTIONS	for brief
       summary of distinctions between HTML::Template::Pro and HTML::Template.

       Call new() to create a new Template object:

	 my $template =	HTML::Template->new( filename => 'file.tmpl',
					     option => 'value'

       You must	call new() with	at least one name => value pair	specifying how
       to access the template text.  You can use "filename => 'file.tmpl'" to
       specify a filename to be	opened as the template.	 Alternately you can

	 my $t = HTML::Template->new( scalarref	=> $ref_to_template_text,
				      option =>	'value'


	 my $t = HTML::Template->new( arrayref => $ref_to_array_of_lines ,
				      option =>	'value'

       These initialize	the template from in-memory resources.	In almost
       every case you'll want to use the filename parameter.  If you're
       worried about all the disk access from reading a	template file just use
       mod_perl	and the	cache option detailed below.

       You can also read the template from an already opened filehandle,
       either traditionally as a glob or as a FileHandle:

	 my $t = HTML::Template->new( filehandle => *FH, option	=> 'value');

       The four	new() calling methods can also be accessed as below, if	you

	 my $t = HTML::Template->new_file('file.tmpl', option => 'value');

	 my $t = HTML::Template->new_scalar_ref($ref_to_template_text,
					       option => 'value');

	 my $t = HTML::Template->new_array_ref($ref_to_array_of_lines,
					      option =>	'value');

	 my $t = HTML::Template->new_filehandle($fh,
					      option =>	'value');

       And as a	final option, for those	that might prefer it, you can call new

	 my $t = HTML::Template->new(type => 'filename',
				     source => 'file.tmpl');

       Which works for all three of the	source types.

       If the environment variable HTML_TEMPLATE_ROOT is set and your filename
       doesn't begin with /, then the path will	be relative to the value of
       $HTML_TEMPLATE_ROOT.  Example - if the environment variable
       HTML_TEMPLATE_ROOT is set to "/home/sam"	and I call
       HTML::Template->new() with filename set to "sam.tmpl", the
       HTML::Template will try to open "/home/sam/sam.tmpl" to access the
       template	file.  You can also affect the search path for files with the
       "path" option to	new() -	see below for more information.

       You can modify the Template object's behavior with new().  The options
       are available:

       Error Detection Options
	   o   die_on_bad_params - if set to 0 the module will let you call
	       $template->param(param_name => 'value') even if 'param_name'
	       doesn't exist in	the template body.  Defaults to	1 in

	       HTML::Template::Pro always use die_on_bad_params	=> 0.  It
	       currently can't be changed, because HTML::Template::Pro can't
	       know whether a parameter	is bad until it	finishes output.

	       Note that it is wrapper-only option: it is not implemented in
	       the htmltmplpro C library.

	   o   force_untaint - if set to 1 the module will not allow you to
	       set unescaped parameters	with tainted values. If	set to 2 you
	       will have to untaint all	parameters, including ones with	the
	       escape attribute.  This option makes sure you untaint
	       everything so you don't accidentally introduce e.g. cross-site-
	       scripting (CSS) vulnerabilities.	Requires taint mode. Defaults
	       to 0.

	       In the original HTML::Template, if the "force_untaint" option
	       is set an error occurs if you try to set	a value	that is
	       tainted in the param() call. In HTML::Template::Pro, an error
	       occurs when output is called.

	       Note that the tainted value will	never be printed; but, to
	       completely suppress output, one should use call to output()
	       that returns string, like print $tmpl->output();	Then output()
	       will die	before it returns the string to	print.

	       Note that it is wrapper-only perl-specific option: it is	not
	       implemented in the htmltmplpro C	library.

	   o   strict -	if set to 0 the	module will allow things that look
	       like they might be TMPL_* tags to get by	without	dieing.


	       Would normally cause an error, but if you call new with strict
	       => 0, HTML::Template will ignore	it.  Defaults to 1.

	       HTML::Template::Pro always implies strict => 0.

       Caching Options
	   HTML::Template use many caching options such	as cache,
	   shared_cache, double_cache, blind_cache, file_cache,
	   file_cache_dir, file_cache_dir_mode,	double_file_cache to cache
	   preparsed html templates.

	   Since HTML::Template::Pro parses and	outputs	templates at once, it
	   silently ignores those options.

       Filesystem Options
	   o   path - you can set this variable	with a list of paths to	search
	       for files specified with	the "filename" option to new() and for
	       files included with the <TMPL_INCLUDE> tag.  This list is only
	       consulted when the filename is relative.	 The
	       HTML_TEMPLATE_ROOT environment variable is always tried first
	       if it exists.  Also, if HTML_TEMPLATE_ROOT is set then an
	       attempt will be made to prepend HTML_TEMPLATE_ROOT onto paths
	       in the path array.  In the case of a <TMPL_INCLUDE> file, the
	       path to the including file is also tried	before path is


		  my $template = HTML::Template->new( filename => 'file.tmpl',
						      path => [	'/path/to/templates',

	       NOTE: the paths in the path list	must be	expressed as UNIX
	       paths, separated	by the forward-slash character ('/').

	   o   search_path_on_include -	if set to a true value the module will
	       search from the top of the array	of paths specified by the path
	       option on every <TMPL_INCLUDE> and use the first	matching
	       template	found.	The normal behavior is to look only in the
	       current directory for a template	to include.  Defaults to 0.

       Debugging Options
	   o   debug - if set to 1 the module will write random	debugging
	       information to STDERR.  Defaults	to 0.

	   o   HTML::Template use many cache debug options such	as
	       stack_debug, cache_debug, shared_cache_debug, memory_debug.
	       Since HTML::Template::Pro parses	and outputs templates at once,
	       it silently ignores those options.

       Miscellaneous Options
	   o   associate - this	option allows you to inherit the parameter
	       values from other objects.  The only requirement	for the	other
	       object is that it have a	"param()" method that works like
	       HTML::Template's	"param()".  A good candidate would be a
	       query object.  Example:

		 my $query = new CGI;
		 my $template =	HTML::Template->new(filename =>	'template.tmpl',
						    associate => $query);

	       Now, "$template->output()" will act as though

		 $template->param('FormField', $cgi->param('FormField'));

	       had been	specified for each key/value pair that would be
	       provided	by the "$cgi->param()" method.	Parameters you set
	       directly	take precedence	over associated	parameters.

	       You can specify multiple	objects	to associate by	passing	an
	       anonymous array to the associate	option.	 They are searched for
	       parameters in the order they appear:

		 my $template =	HTML::Template->new(filename =>	'template.tmpl',
						    associate => [$query, $other_obj]);

	       NOTE: If	the option case_sensitive => 0,	the parameter names
	       are matched in a	case-insensitive manner.  If you have two
	       parameters in a CGI object like 'NAME' and 'Name' one will be
	       chosen randomly by associate.  This behavior can	be changed by
	       setting option case_sensitive to	1.

	   o   case_sensitive -	setting	this option to true causes
	       HTML::Template to treat template	variable names case-
	       sensitively.  The following example would only set one
	       parameter without the "case_sensitive" option:

		 my $template =	HTML::Template->new(filename =>	'template.tmpl',
						    case_sensitive => 1);
		   FieldA => 'foo',
		   fIELDa => 'bar',

	       This option defaults to off to keep compatibility with
	       HTML::Template.	Nevertheless, setting case_sensitive =>	1 is
	       encouraged, because it significantly improves performance.

	       If case_sensitive is set	to 0, the perl wrapper is forced to
	       lowercase keys in every hash it will find in "param" tree,
	       which is	sometimes an expensive operation. To avoid this, set
	       case_sensitive => 1.

	       If case conversion is necessary,	there is an alternative
	       lightweight option tmpl_var_case, which is HTML::Template::Pro

	       Note that case_sensitive	is wrapper-only	option:	it is not
	       implemented in the htmltmplpro C	library.

	   o   tmpl_var_case - this option is similar to case_sensitive, but
	       is implemented directly in the htmltmplpro C library.  Instead
	       of converting keys in every hash	of "param" tree, it converts
	       the name	of variable.

	       For example, in case of <tmpl_var name="CamelCaseName"> setting
	       tmpl_var_case = ASK_NAME_AS_IS |	ASK_NAME_LOWERCASE |
	       ASK_NAME_UPPERCASE will cause HTML::Template::Pro to look into
	       "param" tree for	3 names: CamelCaseName,	camelcasename, and

	       By default, the name is asked "as is".

	   o   loop_context_vars - when	this parameter is set to true (it is
	       false by	default) four loop context variables are made
	       available inside	a loop:	__first__, __last__, __inner__,
	       __odd__.	 They can be used with <TMPL_IF>, <TMPL_UNLESS>	and
	       <TMPL_ELSE> to control how a loop is output.

	       In addition to the above, a __counter__ var is also made
	       available when loop context variables are turned	on.


		     <TMPL_IF NAME="__first__">
		       This only outputs on the	first pass.

		     <TMPL_IF NAME="__odd__">
		       This outputs every other	pass, on the odd passes.

		     <TMPL_UNLESS NAME="__odd__">
		       This outputs every other	pass, on the even passes.

		     <TMPL_IF NAME="__inner__">
		       This outputs on passes that are neither first nor last.

		     This is pass number <TMPL_VAR NAME="__counter__">.

		     <TMPL_IF NAME="__last__">
		       This only outputs on the	last pass.

	       One use of this feature is to provide a "separator" similar in
	       effect to the perl function join().  Example:

		     <TMPL_IF __last__>	and </TMPL_IF>

	       Would output (in	a browser) something like:

		 Apples, Oranges, Brains, Toes,	and Kiwi.

	       Given an	appropriate "param()" call, of course.	NOTE: A	loop
	       with only a single pass will get	both __first__ and __last__
	       set to true, but	not __inner__.

	       NOTE: in	the original HTML::Template with case_sensitive	= 1
	       and loop_context_vars the special loop variables	are available
	       in lower-case only.  In HTML::Template::Pro they	are recognized
	       regardless of case.

	   o   no_includes - set this option to	1 to disallow the
	       <TMPL_INCLUDE> tag in the template file.	 This can be used to
	       make opening untrusted templates	slightly less dangerous.
	       Defaults	to 0.

	   o   max_includes - set this variable	to determine the maximum depth
	       that includes can reach.	 Set to	10 by default.	Including
	       files to	a depth	greater	than this value	causes an error
	       message to be displayed.	 Set to	0 to disable this protection.

	   o   global_vars - normally variables	declared outside a loop	are
	       not available inside a loop.  This option makes <TMPL_VAR>s
	       like global variables in	Perl - they have unlimited scope.
	       This option also	affects	<TMPL_IF> and <TMPL_UNLESS>.


		 This is a normal variable: <TMPL_VAR NORMAL>.<P>

		    Here it is inside the loop:	<TMPL_VAR NORMAL><P>

	       Normally	this wouldn't work as expected,	since <TMPL_VAR
	       NORMAL>'s value outside the loop	is not available inside	the

	       The global_vars option also allows you to access	the values of
	       an enclosing loop within	an inner loop.	For example, in	this
	       loop the	inner loop will	have access to the value of OUTER_VAR
	       in the correct iteration:


	       NOTE: "global_vars" is not "global_loops" (which	does not
	       exist).	That means that	loops you declare at one scope are not
	       available inside	other loops even when "global_vars" is on.

	   o   path_like_variable_scope	- this option switches on a Shigeki
	       Morimoto	extension to HTML::Template::Pro that allows access to
	       variables that are outside the current loop scope using path-
	       like expressions.

	       Example:	{{{ <TMPL_LOOP NAME=class>
		 <TMPL_LOOP NAME=person>
		   <TMPL_VAR NAME="../teacher_name">  <!-- access to
	       class.teacher_name -->
		   <TMPL_VAR NAME="name">
		   <TMPL_VAR NAME="/top_level_value"> <!-- access to top level
	       value -->
		   <TMPL_VAR NAME="age">
		     <TMPL_LOOP	NAME="../../school">  <!-- enter loop before
	       accessing its vars -->
		       <TMPL_VAR NAME="school_name">  <!-- access to
	       [../../]school.school_name -->
		 </TMPL_LOOP> </TMPL_LOOP> }}}

	   o   filter -	this option allows you to specify a filter for your
	       template	files.	A filter is a subroutine that will be called
	       after HTML::Template reads your template	file but before	it
	       starts parsing template tags.

	       In the most simple usage, you simply assign a code reference to
	       the filter parameter.  This subroutine will receive a single
	       argument	- a reference to a string containing the template file
	       text.  Here is an example that accepts templates	with tags that
	       look like "!!!ZAP_VAR FOO!!!" and transforms them into
	       HTML::Template tags:

		  my $filter = sub {
		    my $text_ref = shift;
		    $$text_ref =~ s/!!!ZAP_(.*?)!!!/<TMPL_$1>/g;

		  # open zap.tmpl using	the above filter
		  my $template = HTML::Template->new(filename => 'zap.tmpl',
						     filter => $filter);

	       More complicated	usages are possible.  You can request that
	       your filter receive the template	text as	an array of lines
	       rather than as a	single scalar.	To do that you need to specify
	       your filter using a hash-ref.  In this form you specify the
	       filter using the	"sub" key and the desired argument format
	       using the "format" key.	The available formats are "scalar" and
	       "array".	 Using the "array" format will incur a performance
	       penalty but may be more convenient in some situations.

		  my $template = HTML::Template->new(filename => 'zap.tmpl',
						     filter => { sub =>	$filter,
								 format	=> 'array' });

	       You may also have multiple filters.  This allows	simple filters
	       to be combined for more elaborate functionality.	 To do this
	       you specify an array of filters.	 The filters are applied in
	       the order they are specified.

		  my $template = HTML::Template->new(filename => 'zap.tmpl',
						     filter => [
							  { sub	=> \&decompress,
							    format => 'scalar' },
							  { sub	=> \&remove_spaces,
							    format => 'array' }

	       The specified filters will be called for	any TMPL_INCLUDEed
	       files just as they are for the main template file.

	   o   default_escape -	Set this parameter to "HTML", "URL" or "JS"
	       and HTML::Template will apply the specified escaping to all
	       variables unless	they declare a different escape	in the

       "param()" can be	called in a number of ways

       1) To return a list of parameters in the	template :
	  ( this features is distinct in HTML::Template::Pro:
	  it returns a list of parameters _SET_	after new() )

	  my @parameter_names =	$self->param();

       2) To return the	value set to a param :

	  my $value = $self->param('PARAM');

       3) To set the value of a	parameter :

	     # For simple TMPL_VARs:
	     $self->param(PARAM	=> 'value');

	     # with a subroutine reference that	gets called to get the value
	     # of the scalar.  The sub will receive the	template object	as a
	     # parameter.
	     $self->param(PARAM	=> sub { return	'value'	});

	     # And TMPL_LOOPs:
	     $self->param(LOOP_PARAM =>
			   { PARAM => VALUE_FOR_FIRST_PASS, ...	},

       4) To set the value of a	a number of parameters :

	    # For simple TMPL_VARs:
	    $self->param(PARAM => 'value',
			 PARAM2	=> 'value'

	     # And with	some TMPL_LOOPs:
	     $self->param(PARAM	=> 'value',
			  PARAM2 => 'value',
			  LOOP_PARAM =>
			   { PARAM => VALUE_FOR_FIRST_PASS, ...	},
			   { PARAM => VALUE_FOR_FIRST_PASS, ...	},

       5) To set the value of a	a number of parameters using a hash-ref	:

			     PARAM => 'value',
			     PARAM2 => 'value',
			     LOOP_PARAM	=>
			       { PARAM => VALUE_FOR_FIRST_PASS,	... },
			       { PARAM => VALUE_FOR_SECOND_PASS, ... }
			       { PARAM => VALUE_FOR_FIRST_PASS,	... },
			       { PARAM => VALUE_FOR_SECOND_PASS, ... }

       Sets all	the parameters to undef.  Useful internally, if	nowhere	else!

       output()	returns	the final result of the	template.  In most situations
       you'll want to print this, like:

	  print	$template->output();

       When output is called each occurrence of	<TMPL_VAR NAME=name> is
       replaced	with the value assigned	to "name" via "param()".  If a named
       parameter is unset it is	simply replaced	with ''.  <TMPL_LOOPS> are
       evaluated once per parameter set, accumulating output on	each pass.

       Calling output()	is guaranteed not to change the	state of the Template
       object, in case you were	wondering.  This property is mostly important
       for the internal	implementation of loops.

       You may optionally supply a filehandle to print to automatically	as the
       template	is generated.  This may	improve	performance and	lower memory
       consumption.  Example:

	  $template->output(print_to =>	*STDOUT);

       The return value	is undefined when using	the "print_to" option.

       This method is not supported in HTML::Template::Pro.

       The main	reason for small incompatibilities between HTML::Template and
       HTML::Template::Pro is the fact that HTML::Template builds parsed tree
       of template before anything else. So it has an additional information
       which HTML::Template::Pro obtains during	output.

       In cases	when HTML::Template dies, such as no_includes, bad syntax of
       template, max_includes and so on, HTML::Template::Pro issues warning to
       STDERR and continue.

       the following options are not supported in HTML::Template::Pro:


       The options die_on_bad_params and strict	are ignored.
       HTML::Template::Pro behaves itself as HTML::Template called with
	die_on_bad_params => 0,	strict => 0.

       It currently can't be changed, because HTML::Template::Pro can't	know
       whether a parameter is bad before it start output.  This	may change in
       future releases.

       To keep backward	compatibility with HTML::Template, you should
       explicitly call its new() with die_on_bad_params	=> 0, strict =>	0.

       This method is not supported in HTML::Template::Pro.

       param() without arguments should	return a list of parameters in the
       template.  In HTML::Template::Pro it returns a list of parameters set
       after new().

       With case_sensitive and loop_context_vars the special loop variables
       should be available in lower-case only.

       associate is case_sensitive inside loops.

       When submitting bug reports, be sure to include full details, including
       the VERSION of the module, a test script	and a test template
       demonstrating the problem!

       To define a new function, pass a	"functions" option to new:

	 $t = HTML::Template::Pro->new(filename	=> 'foo.tmpl',
					functions =>
					  { func_name => \&func_handler	});

	 $t = HTML::Template::Expr->new(filename => 'foo.tmpl',
					functions =>
					  { func_name => \&func_handler	});

       Or, you can use "register_function" class method	to register the
       function	globally:

	 HTML::Template::Pro->register_function(func_name => \&func_handler);
	 HTML::Template::Expr->register_function(func_name => \&func_handler);

       You provide a subroutine	reference that will be called during output.
       It will receive as arguments the	parameters specified in	the template.
       For example, here's a function that checks if a directory exists:

	 sub directory_exists {
	   my $dir_name	= shift;
	   return 1 if -d $dir_name;
	   return 0;

       If you call HTML::Template::Expr->new() with a "functions" arg:

	 $t = HTML::Template::Expr->new(filename => 'foo.tmpl',
					functions => {
					   directory_exists => \&directory_exists

       Then you	can use	it in your template:

	 <tmpl_if expr="directory_exists('/home/sam')">

       This can	be abused in ways that make my teeth hurt.

   register_function() extended	usage (HTML::Template::Pro specific)
       "register_function()" can be called in a	number of ways

       1) To fetch the names of	registered functions in	the template:

       o   if "register_function()" was	called in a newly created object it
	   returns a

	      list of function's that set _after_ or _in_ new():

	      my @registered_functions_names = $self->register_function();

       o   in global context "register_function()" will	return a list of _ALL_
	      avalible function's

	      my @all_avalible_functions_names =

	   2) To fetching the function by name:

	      my $function = $self->register_function('FUNCTION_NAME');

	   3) To set a new function:

	       # Set function, that can	be called in templates,	wich are processed
	       # by the	current	object:
	       $self->register_function(foozicate => sub { ... });

	       # Set global function:
	       HTML::Template::Pro->register_function(barify	=> sub { ... });

       for details of "how to defined a	function" see in "EXPR:	DEFINING NEW

       "register_function" class method	can be called in mod_perl's
       to define widely	used common functions to HTML::Template::Expr. Add
       something like this to your

	 use HTML::Template::Pro;

	 HTML::Template::Pro->register_function(foozicate => sub { ... });
	 HTML::Template::Pro->register_function(barify	  => sub { ... });
	 HTML::Template::Pro->register_function(baznate	  => sub { ... });

       HTML::Template::Pro does	not forces the HTML::Template global_vars
       option to be set, whereas currently HTML::Template::Expr	does.  Anyway,
       this also will hopefully	go away	in a future version of
       HTML::Template::Expr, so	if you need global_vars	in your	templates then
       you should set it explicitly.

       to Sam Tregar,

       Original	credits	of HTML::Template:

       This module was the brain child of my boss, Jesse Erlbaum ( ) at Vanguard Media	(	) .  The most original
       idea in this module - the <TMPL_LOOP> - was entirely his.

       Fixes, Bug Reports, Optimizations and Ideas have	been generously
       provided	by:

	  Richard Chen
	  Mike Blazer
	  Adriano Nagelschmidt Rodrigues
	  Andrej Mikus
	  Ilya Obshadko
	  Kevin	Puetz
	  Steve	Reppucci
	  Richard Dice
	  Tom Hukins
	  Eric Zylberstejn
	  David	Glasser
	  Peter	Marelas
	  James	William	Carlson
	  Frank	D. Cringle
	  Winfried Koenig
	  Matthew Wickline
	  Doug Steinwand
	  Drew Taylor
	  Tobias Brox
	  Michael Lloyd
	  Simran Gambhir
	  Chris	Houser <>
	  Larry	Moore
	  Todd Larason
	  Jody Biggs
	  T.J. Mather
	  Martin Schroth
	  Dave Wolfe
	  Kawai	Takanori
	  Peter	Guelich
	  Chris	Nokleberg
	  Ralph	Corderoy
	  William Ward
	  Ade Olonoh
	  Mark Stosberg
	  Lance	Thomas
	  Roland Giersig
	  Jere Julian
	  Peter	Leonard
	  Kenny	Smith
	  Sean P. Scanlon
	  Martin Pfeffer
	  David	Ferrance
	  Gyepi	Sam
	  Darren Chamberlain
	  Paul Baker
	  Gabor	Szabo
	  Craig	Manley
	  Richard Fein
	  The Phalanx Project
	  Sven Neuhaus


       Original	credits	of HTML::Template::Expr:

       The following people have generously submitted bug reports, patches and

	  Peter	Leonard
	  Tatsuhiko Miyagawa


       You can find information	about HTML::Template::Pro at:

       You can find information	about HTML::Template and other related modules

       Sam Tregar, (Main	text)

       I. Vlasenko, <> (Pecularities of	HTML::Template::Pro)

	 HTML::Template	: A module for using HTML Templates with Perl
	 Copyright (C) 2000-2002 Sam Tregar (

	 This module is	free software; you can redistribute it and/or modify it
	 under the terms of either:

	 a) the	GNU General Public License as published	by the Free Software
	 Foundation; either version 1, or (at your option) any later version,


	 b) the	"Artistic License" which comes with this module.

	 This program is distributed in	the hope that it will be useful,
	 but WITHOUT ANY WARRANTY; without even	the implied warranty of
	 the GNU General Public	License	or the Artistic	License	for more details.

	 You should have received a copy of the	Artistic License with this
	 module, in the	file ARTISTIC.	If not,	I'll be	glad to	provide	one.

	 You should have received a copy of the	GNU General Public License
	 along with this program; if not, write	to the Free Software
	 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

perl v5.32.1			  2013-05-13  HTML::Template::PerlInterface(3)


Want to link to this manual page? Use this URL:

home | help