Hello all.  Here's a look at a design for my lastest crazy scheme - a
just-in-time compiler for HTML::Template!  Any and all feedback would be
appreciated.

-sam


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

SYNOPSIS
      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();

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

    Load
        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
        output().

    Compile
        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 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:

    *   The compilation phase takes a long, long time. Depending on your
        system it might take tens of seconds to compile a large template.

    *   The resulting compiled template is much, much faster than a normal
        cached template.

    *   The resulting compiled template requires much 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 proper to
        use the templates!

    I'll be adding some specific numbers to the above list when I have time.

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

    jit_path
        This is the path that the module will use to store compiled
        templates. It needs to be both readable and writeable. This
        directory will slowly grow over time as templates are changed are
        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.

    no_compile
        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.

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

       cache (all modes)
       associate
       case_sensitive
       loop_context_vars
       global_vars
       print_to

    It also doesn't support CODE-ref params or the query() method. As
    development progresses I hope to eventually address all of these
    limitations.

BUGS
    When you find a bug, join the mailing list and tell us about it
    ([EMAIL PROTECTED]). You can join the HTML::Template mailing-list by
    sending a blank email to [EMAIL PROTECTED] Of course, you
    can still email me directly ([EMAIL PROTECTED]) 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!

AUTHOR
    Sam Tregar <[EMAIL PROTECTED]>

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

    Copyright (C) 2001 Sam Tregar ([EMAIL PROTECTED])

    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
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See either 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 USA



---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to