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

FreeBSD Manual Pages


home | help
JIT(3)		      User Contributed Perl Documentation		JIT(3)

       HTML::Template::JIT - a just-in-time compiler for HTML::Template

	 use HTML::Template::JIT;

	 my $template =	HTML::Template::JIT->new(filename => 'foo.tmpl',
						 jit_path => '/tmp/jit',
	 $template->param(banana_count => 10);
	 print $template->output();

       This module provides a just-in-time compiler for	HTML::Template.	 The
       module works in two phases:

	   When	new() is called	the module checks to see if it already has an
	   up-to-date version of your template compiled.  If it	does it	loads
	   the compiled	version	and returns you	a handle to call param() and

	   If your template needs to be	compiled - either because it has
	   changed or because it has never been	compiled - then
	   HTML::Template::JIT loads HTML::Template::JIT::Compiler which uses
	   HTML::Template and Inline::C	to compile your	template to native
	   machine instructions.

	   The compiled	form is	saved to disk in the jit_path directory	and
	   control returns to the Load phase.

       This may	sound a	lot like the way HTML::Template's cache	mode works but
       there are some significant differences:

       o   The compilation phase takes a long time.  Depending on your system
	   it might take several seconds to compile a large template.

       o   The resulting compiled template is much faster than a normal	cached
	   template.  My benchmarks show HTML::Template::JIT, with a
	   precompiled template, performing 4 to 8 times faster	than
	   HTML::Template in cache mode.

       o   The resulting compiled template should use less memory than a
	   normal cached template.  Also, if all your templates	are already
	   compiled then you don't even	have to	load HTML::Template to use the

       Usage is	the same as normal HTML::Template usage	with a few addition
       new() options.  The new options are:

	   This	is the path that the module will use to	store compiled
	   modules.  It	needs to be both readable and writeable.  This
	   directory will slowly grow over time	as templates are changed and
	   recompiled so you might want	to periodically	clean it out.
	   HTML::Template::JIT might get better	at cleaning-up after itself in
	   a future version.

	   This	option tells the module	to never compile templates.  If	it
	   can't find a	compiled version of a template then it croak()s	rather
	   than	load HTML::Template::JIT::Compiler.  You might want to use
	   this	option if you've precompiled your templates and	want to	make
	   sure	your users are never subjected to the lag of a compiler	run.

	   Spits out a bunch of	obscure	debugging on STDERR.  Note that	you'll
	   need	to have	a working version of the "indent" utility in your path
	   to use this option.	HTML::Template::JIT uses "indent" to make
	   generated C code readable.

	   A special version of	the HTML::Template print_to option is
	   available to	print output to	stdout rather than accumulating	in a
	   variable.  Set this option to 1 and output()	will print the
	   template contents directly to STDOUT.  Defaults to 0.

	   NOTE: Using print_to_stdout will result in significant memory
	   savings for large templates.	 However my testing shows a slight
	   slowdown in overall performance compared to normal
	   HTML::Template::JIT usage.

       This version is rather limited.	It doesn't support the following

	  cache	(all modes)
	  scalarref (and friends)
	  arrayref  (and friends)

       Included	files are not checked for changes when checking	a compiled
       template	for freshness.

       CODE-ref	params are not supported.

       The query() method is not supported.

       It's not	as fast	as it could be - I'd like to see it reach somewhere
       around 10x faster than normal HTML::Template.

       I wouldn't expect this module to	work with UTF-8	unless your C compiler
       will accept UTF-8 inside	C strings.  I think that would be a violation
       of the C	standard, so I think I need to do some work here instead.

       As development progresses I hope	to eventually address all of these

       When you	find a bug join	the mailing list and tell us about it.	You
       can join	the HTML::Template mailing-list	by visiting:

       Of course, you can still	email me directly ( with	bugs,
       but I reserve the right to forward bug reports to the mailing list.

       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!

       Sam Tregar <>

       HTML::Template::JIT : Just-in-time compiler for HTML::Template

       Copyright (C) 2001 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, or

       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
       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 USA

perl v5.32.1			  2005-12-22				JIT(3)


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

home | help