Small cover
Embedding Perl in HTML with Mason
Dave Rolsky
Ken Williams

Table of Contents | Foreword | Preface
Chapters: 1 2 3 4 5 6 7 8 9 10 11 12
Appendices: A B C D
Glossary | Colophon | Copyright

Chapter 6: The Lexer, Compiler, Resolver, and Interpreter Objects

Now that you're familiar with Mason's basic syntax and some of its more advanced features, it's time to explore the details of how the various pieces of the Mason architecture work together to process components. By knowing the framework well, you can use its pieces to your advantage, processing components in ways that match your intentions.

In this chapter we'll discuss four of the persistent objects in the Mason framework: the Interpreter, Resolver, Lexer, and Compiler. These objects are created once (in a mod_perl setting, they're typically created when the server is starting up) and then serve many Mason requests, each of which may involve processing many Mason components.

Each of these four objects has a distinct purpose. The Resolver is responsible for all interaction with the underlying component source storage mechanism, which is typically a set of directories on a filesystem. The main job of the Resolver is to accept a component path as input and return various properties of the component such as its source, time of last modification, unique identifier, and so on.

The Lexer is responsible for actually processing the component source code and finding the Mason directives within it. It interacts quite closely with the Compiler, which takes the Lexer's output and generates a Mason component object suitable for interpretation at runtime.

The Interpreter ties the other three objects together. It is responsible for taking a component path and arguments and generating the resultant output. This involves getting the component from the resolver, compiling it, then caching the compiled version so that next time the interpreter encounters the same component it can skip the resolving and compiling phases.

Figure 6-1 illustrates the relationship between these four objects. The Interpreter has a Compiler and a Resolver, and the Compiler has a Lexer.

Figure 6-1. The Interpreter and its cronies

Passing Parameters to Mason Classes

An interesting feature of the Mason code is that, if a particular object contains another object, the containing object will accept constructor parameters intended for the contained object. For example, the Interpreter object will accept parameters intended for the Compiler or Resolver and do the right thing with them. This means that you often don't need to know exactly where a parameter goes. You just pass it to the object at the top of the chain.

Even better, if you decide to create your own Resolver for use with Mason, the Interpreter will take any parameters that your Resolver accepts -- not the parameters defined by Mason's default Resolver class.

Also, if an object creates multiple delayed instances of another class, as the Interpreter does with Request objects, it will accept the created class's parameters in the same way, passing them to the created class at the appropriate time. So if you pass the autoflush parameter to the Interpreter's constructor, it will store this value and pass it to any Request objects it creates later.

This system was motivated in part by the fact that many users want to be able to configure Mason from an Apache config file. Under this system, the user just sets a certain configuration directive (such as MasonAutoflush1 to set the autoflush parameter) in her httpd.conf file, and it gets directed automatically to the Request objects when they are created.

The details of how this system works are fairly magical and the code involved is so funky its creators don't know whether to rejoice or weep, but it works, and you can take advantage of this if you ever need to create your own custom Mason classes. Chapter 12 covers this in its discussion of the Class::Container class, where all the funkiness is located.

The Lexer

Mason's built-in Lexer class is, appropriately enough, HTML::Mason::Lexer . All it does is parse the text of Mason components and pass off the sections it finds to the Compiler. As of Version 1.10, the Lexer doesn't actually accept any parameters that alter its behavior, so there's not much for us to say in this section.

Future versions of Mason may include other Lexer classes to handle alternate source formats. Some people -- crazy people, we assure you -- have expressed a desire to write Mason components in XML, and it would be fairly simple to plug in a new Lexer class to handle this. If you're one of these crazy people, you may be interested in Chapter 12 to see how to use objects of your own design as pieces of the Mason framework.

By the way, you may be wondering why the Lexer isn't called a Parser, since its main job seems to be to parse the source of a component. The answer is that previous implementations of Mason had a Parser class with a different interface and role, and a different name was necessary to maintain forward (though not backward) compatibility.

The Compiler

By default, Mason will use the HTML::Mason::Compiler::ToObject class to do its compilation. It is a subclass of the generic HTML::Mason::Compiler class, so we describe here all parameters that the ToObject variety will accept, including parameters inherited from its parent:

  • allow_globals

    You may want to allow access to certain Perl variables across all components without declaring or initializing them each time. For instance, you might want to let all components share access to a $dbh variable that contains a DBI database handle, or you might want to allow access to an Apache::Session%session variable.

    For cases like these, you can set the allow_globals parameter to an array reference containing the names of any global variables you want to declare. Think of it like a broadly scoped use vars declaration; in fact, that's exactly the way it's implemented under the hood. If you wanted to allow the $dbh and %session variables, you would pass an allow_globals parameter like the following:

      allow_globals => ['$dbh', '%session']

    Or in an Apache configuration file:

      PerlSetVar MasonAllowGlobals $dbh
      PerlAddVar MasonAllowGlobals %session

    The allow_globals parameter can be used effectively with the Perl local() function in an autohandler. The top-level autohandler is a convenient place to initialize global variables, and local() is exactly the right tool to ensure that they're properly cleaned up at the end of the request:

      # In the top-level autohandler:
        # $dbh and %session have been declared using 'allow_globals'
        local $dbh = DBI->connect(...connection parameters...);
        local *session;  # Localize the glob so the tie() expires properly
        tie %session, 'Apache::Session::MySQL',
          { Handle => $dbh, LockHandle => $dbh };

    Remember, don't go too crazy with globals: too many of them in the same process space can get very difficult to manage, and in an environment like Mason's, especially under mod_perl, the process space can be very large and long-lasting. But a few well-placed and well-scoped globals can make life nice.

  • default_escape_flags

    This parameter allows you to set a global default for the escape flags in <%$substitution %> tags. For instance, if you set default_escape_flags to 'h', then all substitution tags in your components will pass through HTML escaping. If you decide that an individual substitution tag should not obey the default_escape_flag parameter, you can use the special escape flag 'n' to ignore the default setting and add whatever additional flags you might want to employ for that particular substitution tag.

      in compiler settings:
      default_escape_flags => 'h',
      in a component:
      You have <% $amount %> clams in your aquarium.
      This is <% $difference |n %> more than your rival has.
      <a href="emotion.html?emotion=<% $emotion |nu %>">Visit 
       your <% $emotion %> place!</a>
      acts as if you had written:
      You have <% $amount |h %> clams in your aquarium.
      This is <% $difference %> more than your rival has.
      <a href="emotion.html?emotion=<% $emotion |u %>">Visit 
       your <% $emotion |h %> place!</a>
  • use_strict

    By default, all components will be run under Perl's strict pragma, which forces you to declare any Perl variables you use in your component. This is a very good feature, as the strict pragma can help you avoid all kinds of programming slip-ups that may lead to mysterious and intermittent errors. If, for some sick reason you want to turn off the strict pragma for all your components, you can set the use_strict parameter to a false value and watch all hell get unleashed as you shoot your Mason application in the foot.

    A far better solution is to just insert no strict; into your code whenever you use a construct that's not allowed under the strict pragma; this way your casual usage will be allowed in only the smallest enclosing block (in the worst case, one entire component). Even better would be to find a way to achieve your goals while obeying the rules of the strict pragma, because the rules generally enforce good programming practice.

  • in_package

    The code written in <%perl> sections (or other component sections that contain Perl code) must be compiled in the context of some package, and the default package is HTML::Mason::Commands .2 To specify a different package, set the in_package compiler parameter. Under normal circumstances you shouldn't concern yourself with this package name (almost everything in Mason is done with lexically scoped my variables), but for historical reasons you're allowed to change it to whatever package you want.

    Related settings are the Compiler's allow_globals parameter/method and the Interpreter's set_global() method. These let you declare and assign to variables in the package you specified with in_package, without actually needing to specify that package again by name.

    You may also want to control the package name in order to import symbols (subroutines, constants, etc.) for use in components. Although the importing of subroutines seems to be gradually going out of style as people adopt more strict object-oriented programming practices, importing constants is still quite popular, and especially useful in a web context, where various numerical values are used as HTTP status codes. The following example, meant for use in an Apache server configuration file, exports all the common Apache constants so they can be used inside the site's Mason components.

      PerlSetVar MasonInPackage My::Application
        package My::Application;
        use Apache::Constants qw(:common);
  • comp_class

    By default, components created by the compiler will be created by calling the HTML::Mason::Component class's new() method. If you want the components to be objects of a different class, perhaps one of your own creation, you may specify a different class name in the comp_class parameter.

  • lexer

    As of Release 1.10 you can redesign Mason on the fly by subclassing one or more of Mason's core classes and extending (or reducing, if that's your game) its functionality. In an informal sense, we speak of Release 1.10 as having made Mason more "pluggable."

    By default, Mason creates a Lexer object in the HTML::Mason::Lexer class. By passing a lexer parameter to the Compiler, you can specify a different Lexer object with different behavior. For instance, if you like everything about Mason except for the syntax it uses for its component files, you could create a Lexer object that lets you write your components in a format that works well with your favorite WYSIWYG HTML editor, in a Python-esque whitespace soup, or however you like.

    The lexer parameter should contain an object that inherits from the HTML::Mason::Lexer class. As an alternative to creating the object yourself and passing it to the Compiler, you may instead specify a lexer_class parameter, and the Compiler will create a new Lexer object for you by calling the specified package's new() method. This alternative is often preferable when it's inconvenient to create new Perl objects, such as when you're configuring Mason from a web server's configuration file. In this case, you should also pass any parameters that are needed for your Lexer's new() method, and they will find their way there.

Altering Every Component's Content

Several access points let you step in to the compilation process and alter the text of each component as it gets processed. The preprocess, postprocess_perl, postprocess_text, preamble, and postamble parameters let you exert a bit of ad hoc control over Mason's processing of your components.

Figure 6-2 illustrates the role of each of these five parameters.

Figure 6-2. Component processing hooks

  • preprocess

    With the preprocess parameter, you may specify a reference to a subroutine through which all components should be preprocessed before the compiler gets hold of them. The compiler will pass your subroutine the entire text of the component in a scalar reference. Your subroutine should modify the text in that reference directly -- any return value will be ignored.

  • postprocess_perl

    The sections of a Mason component can be coarsely divided into three categories: Perl sections (%-lines, <%init> blocks, and so on), sections for special Mason directives (<%args> blocks, <%flags> blocks, and so on), and plain text sections (anything outside the other two types of sections). The Perl and text sections can become part of the component's final output, whereas the Mason directives control how the output is created.

    Similar to the preprocess directive, the postprocess_perl and postprocess_text directives let you step in and change a component's source before it is compiled. However, with these directives you're stepping into the action one step later, after the component source has been divided into the three types of sections just mentioned. Accordingly, the postprocess_perl parameter lets you process Perl sections, and the postprocess_text parameter lets you process text sections. There is no corresponding hook for postprocessing the special Mason sections.

    As with the preprocess directive, the postprocess directives should specify a subroutine reference. Mason will pass the component source sections one at a time (again, as a scalar reference) to the subroutine you specify, and your subroutine should modify the text in-place.

  • preamble

    If you specify a string value for the preamble parameter, the text you provide will be prepended to every component that gets processed with this compiler. The string should contain Perl code, not Mason code, as it gets inserted verbatim into the component object after compilation. The default preamble is the empty string.

  • postamble

    The postamble parameter is just like the preamble parameter, except that the string you specify will get appended to the component rather than prepended. Like the preamble, the default postamble is the empty string.

    One use for preamble and postamble might be an execution trace, in which you log the start and end events of each component.

    One potential gotcha: if you have an explicit return statement in a component, no further code in that component will run, including code in its postamble. Thus it's not necessarily a good place to run cleanup code, unless you're positive you're never going to use return statements. Cleanup code is usually better placed in an autohandler or similar location. An alternate trick is to create objects in your preamble code and rely on their DESTROY methods to tell you when they're going out of scope.

Compiler Methods

Once an HTML::Mason::Compiler::ToObject object is created, the following methods may be invoked. Many of them simply return the value of a parameter that was passed (or set by default) when the Compiler was created. Some methods may be used by developers when building a site, while other methods should be called only by the various other pieces in the Mason framework. Though you may need to know how the latter methods work if you start plugging your own modules into the framework, you'll need to read the Mason documentation to find out more about those methods, as we don't discuss them here.

The compiler methods are comp_class() , in_package() , preamble() , postamble() , use_strict() , allow_globals() , default_escape_flags() , preprocess() , postprocess_perl() , postprocess_text() , and lexer() .

Each of these methods returns the given property of the Compiler, which was typically set when the Compiler was created. If you pass an argument to these methods, you may also change the given property. One typically doesn't need to change any of the Compiler's properties after creation, but interesting effects could be achieved by doing so:

  % my $save_pkg = $m->interp->compiler->in_package;
  % $m->interp->compiler->in_package('MyApp::OtherPackage');
  <& /some/other/component &>
  % $m->interp->compiler->in_package($save_pkg);

The preceding example will compile the component /some/other/component -- and any components it calls -- in the package MyApp::OtherPackage rather than the default HTML::Mason::Commands package or whatever other package you specified using in_package.

Of course, this technique will work only if /some/other/component actually needs to be compiled at this point in the code; it may already be compiled and cached in memory or on disk, in which case changing the in_package property (or any other Compiler property) will have no effect. Because of this, changing Compiler properties after the Compiler is created is neither a great idea nor officially supported, but if you know what you're doing, you can use it for whatever diabolical purposes you have in mind.

The Resolver

The default Resolver, HTML::Mason::Resolver::File , finds components and their meta-information (for example, modification date and file length) on disk. The Resolver is a pretty simple thing, but it's useful to give it its own place in the pluggable Mason framework because it allows a developer to use whatever storage mechanism she wants for her components.

The HTML::Mason::Resolver::File class accepts only one parameter:

  • comp_root

    The comp_root parameter is Mason's component root. It specifies where components may be found on disk. It is roughly analogous to Perl's @INC array or the shell's $PATH variable. You may specify comp_root as a string containing the directory in which to search for components or as an array reference of array references like so:

      my $comp_root = [
                       [web    => '/usr/local/httpd/documents'],
                       [shared => '/usr/local/mason/comps'],
                       [custom => '/home/ken/my_components'],
      my $resolver = HTML::Mason::Resolver::File->new(comp_root => $comp_root);

    Every time the Resolver is asked to find a component on disk, it will search these three directories in the given order, as discussed in Chapter 5.

    After a Resolver has been created, you may call its comp_root() method, which returns the value of the comp_root parameter as it was set at creation time.

If you don't provide a comp_root parameter, it defaults to something reasonably sensible. In a web context it defaults to the server's DocumentRoot; otherwise, it defaults to the current working directory.

The Interpreter

The Interpreter is the center of Mason's universe. It is responsible for coordinating the activities of the Compiler and Resolver, as well as creating Request objects. Its main task involves receiving requests for components and generating the resultant output of those requests. It is also responsible for several tasks behind the scenes, such as caching components in memory or on disk. It exposes only a small part of its object API for public use; its primary interface is via its constructor, the new() method.

The new() method accepts lots of parameters. It accepts any parameter that its Resolver or Compiler (and through the Compiler, the Lexer) classes accept in their new() methods; these parameters will be transparently passed along to the correct constructor. It also accepts the following parameters of its own:

  • autohandler_name

    This parameter specifies the name that Mason uses for autohandler files. The default name is "autohandler."

  • code_cache_max_size

    This parameter sets the limit, in bytes, of the in-memory cache for component code. The default is 10 megabytes (10 * 1024 * 1024). This is not the same thing as the on-disk cache for component code, which will keep growing without bound until all components are cached on disk. It is also different from the data caches, the sizes of which you control through the $m->cache and $m->cache_self methods.

  • data_dir

    This parameter specifies the directory under which Mason stores its various data, such as compiled components, cached data, and so on. This cannot be changed after the Interpreter is created.

  • ignore_warnings_expr

    Normally, warnings issued during the loading of a component are treated as fatal errors by Mason. Mason will ignore warnings that match the regular expression specified in this parameter. The default setting is qr/Subroutine .* redefined/i. If you change this parameter, you will probably want to make sure that this particular warning continues to be ignored, as this allows you to declare named subroutines in the <%once> section of components and not cause an error when the component is reloaded and the subroutine is redefined.

  • preloads

    This parameter takes a list of components to be preloaded when the Interpreter is created. In a mod_perl setting this can lead to substantial memory savings and better performance, since the components will be compiled in the server's parent process and initially shared among the server children. It also reduces the amount of processing needed during individual requests, as preloaded components will be standing at the ready.

    The list of components can either be specified by listing each component path individually or by using glob()-style patterns to specify several component paths.

  • static_source

    Passing a true value for this parameter causes Mason to execute in "static source" mode, which means that it will compile a source file only once, ignoring subsequent changes. In addition, it will resolve a given path only once, so adding or removing components will not be noticed by the interpreter.

    If you do want to make changes to components when Mason is in this mode, you will need to delete all of Mason's object files and, if you are running Mason under mod_perl, restart the Apache server.

    This mode is useful in order to gain a small performance boost on a heavily trafficked site when your components don't change very often. If you don't need the performance boost, then don't bother turning this mode on, as it just makes for extra administrative work when you change components.

  • compiler

    As we mentioned before, each Interpreter object creates a Compiler and a Resolver object that it works with to serve requests. You can substantially alter the compilation or resolution tasks by providing your own Compiler or Resolver when creating the Interpreter, passing them as the values for the compiler or resolver parameters. Alternatively, you may pass compiler_class or resolver_class parameters (and any arguments required by those classes' new() methods) and allow the Interpreter to construct the Compiler or Resolver from the other parameters you specify:

      my $interp = HTML::Mason::Interpreter->new
         resolver_class => 'MyApp::Resolver',
         compiler_class => 'MyApp::Compiler',
         comp_root => '/home/httpd/docs',  # Goes to resolver
         default_escape_flags => 'h',      # Goes to compiler

    By default, the Compiler will be an HTML::Mason::Compiler::ToObject object, and the Resolver will be an HTML::Mason::Resolver::File object.

Request Parameters Passed to the Interpreter

Besides the Interpreter's own parameters, you can pass the Interpreter any parameter that the Request object accepts. These parameters will be saved internally and used as defaults when making a new Request object.

The parameters that can be set are: autoflush , data_cache_defaults , dhandler , error_mode , error_format , and out_method .

Besides accepting these as constructor parameters, the Interpreter also provides get/set accessors for these attribute. Setting these attributes in the interpreter will change the attribute for all future Requests, though it will not change the current Request.


1. All initialization parameters have corresponding Apache configuration names, found by switching from lower_case_with_underscores to StudlyCaps and prepending "Mason." -- Return.

2. This package name is purely historical; it may be changed in the future. -- Return.

Table of Contents | Foreword | Preface
Chapters: 1 2 3 4 5 6 7 8 9 10 11 12
Appendices: A B C D
Glossary | Colophon | Copyright

These HTML pages were created by running this script against the pseudo-POD source.