| Filename | /usr/lib/x86_64-linux-gnu/perl5/5.28/Template/Context.pm |
| Statements | Executed 35309593 statements in 99.2s |
| Calls | P | F | Exclusive Time |
Inclusive Time |
Subroutine |
|---|---|---|---|---|---|
| 384174 | 2 | 2 | 28.5s | 2133s | Template::Context::process (recurses: max depth 41, inclusive time 39808s) |
| 383161 | 1 | 1 | 26.9s | 112s | Template::Context::_init |
| 767335 | 2 | 2 | 12.7s | 433s | Template::Context::template |
| 383161 | 1 | 1 | 6.17s | 7.88s | Template::Context::delocalise |
| 383161 | 1 | 1 | 3.38s | 3.57s | Template::Context::DESTROY |
| 383161 | 1 | 1 | 3.30s | 12.2s | Template::Context::localise |
| 383161 | 1 | 1 | 1.71s | 1.71s | Template::Context::reset |
| 384174 | 1 | 1 | 1.29s | 1.29s | Template::Context::visit |
| 384174 | 1 | 1 | 967ms | 967ms | Template::Context::leave |
| 384174 | 1 | 1 | 810ms | 810ms | Template::Context::stash |
| 1013 | 2 | 1 | 28.4ms | 1557s | Template::Context::include (recurses: max depth 1, inclusive time 163s) |
| 1013 | 1 | 1 | 1.50ms | 1.50ms | Template::Context::CORE:subst (opcode) |
| 1 | 1 | 1 | 18µs | 23µs | Template::Context::BEGIN@23 |
| 1 | 1 | 1 | 12µs | 13µs | Template::Context::BEGIN@27 |
| 1 | 1 | 1 | 10µs | 41µs | Template::Context::BEGIN@24 |
| 1 | 1 | 1 | 10µs | 94µs | Template::Context::BEGIN@25 |
| 1 | 1 | 1 | 10µs | 10µs | Template::Context::BEGIN@30 |
| 1 | 1 | 1 | 9µs | 36µs | Template::Context::BEGIN@29 |
| 1 | 1 | 1 | 8µs | 64µs | Template::Context::BEGIN@33 |
| 1 | 1 | 1 | 7µs | 37µs | Template::Context::BEGIN@31 |
| 1 | 1 | 1 | 6µs | 7µs | Template::Context::BEGIN@28 |
| 1 | 1 | 1 | 6µs | 27µs | Template::Context::BEGIN@35 |
| 1 | 1 | 1 | 6µs | 29µs | Template::Context::BEGIN@34 |
| 3 | 3 | 1 | 1µs | 1µs | Template::Context::__ANON__ (xsub) |
| 0 | 0 | 0 | 0s | 0s | Template::Context::AUTOLOAD |
| 0 | 0 | 0 | 0s | 0s | Template::Context::_dump |
| 0 | 0 | 0 | 0s | 0s | Template::Context::catch |
| 0 | 0 | 0 | 0s | 0s | Template::Context::debugging |
| 0 | 0 | 0 | 0s | 0s | Template::Context::define_block |
| 0 | 0 | 0 | 0s | 0s | Template::Context::define_filter |
| 0 | 0 | 0 | 0s | 0s | Template::Context::define_view |
| 0 | 0 | 0 | 0s | 0s | Template::Context::define_views |
| 0 | 0 | 0 | 0s | 0s | Template::Context::define_vmethod |
| 0 | 0 | 0 | 0s | 0s | Template::Context::filter |
| 0 | 0 | 0 | 0s | 0s | Template::Context::insert |
| 0 | 0 | 0 | 0s | 0s | Template::Context::plugin |
| 0 | 0 | 0 | 0s | 0s | Template::Context::throw |
| 0 | 0 | 0 | 0s | 0s | Template::Context::view |
| Line | State ments |
Time on line |
Calls | Time in subs |
Code |
|---|---|---|---|---|---|
| 1 | #============================================================= -*-Perl-*- | ||||
| 2 | # | ||||
| 3 | # Template::Context | ||||
| 4 | # | ||||
| 5 | # DESCRIPTION | ||||
| 6 | # Module defining a context in which a template document is processed. | ||||
| 7 | # This is the runtime processing interface through which templates | ||||
| 8 | # can access the functionality of the Template Toolkit. | ||||
| 9 | # | ||||
| 10 | # AUTHOR | ||||
| 11 | # Andy Wardley <abw@wardley.org> | ||||
| 12 | # | ||||
| 13 | # COPYRIGHT | ||||
| 14 | # Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved. | ||||
| 15 | # | ||||
| 16 | # This module is free software; you can redistribute it and/or | ||||
| 17 | # modify it under the same terms as Perl itself. | ||||
| 18 | # | ||||
| 19 | #============================================================================ | ||||
| 20 | |||||
| 21 | package Template::Context; | ||||
| 22 | |||||
| 23 | 2 | 29µs | 2 | 28µs | # spent 23µs (18+5) within Template::Context::BEGIN@23 which was called:
# once (18µs+5µs) by Template::Config::load at line 23 # spent 23µs making 1 call to Template::Context::BEGIN@23
# spent 5µs making 1 call to strict::import |
| 24 | 2 | 28µs | 2 | 72µs | # spent 41µs (10+31) within Template::Context::BEGIN@24 which was called:
# once (10µs+31µs) by Template::Config::load at line 24 # spent 41µs making 1 call to Template::Context::BEGIN@24
# spent 31µs making 1 call to warnings::import |
| 25 | 2 | 33µs | 2 | 178µs | # spent 94µs (10+84) within Template::Context::BEGIN@25 which was called:
# once (10µs+84µs) by Template::Config::load at line 25 # spent 94µs making 1 call to Template::Context::BEGIN@25
# spent 84µs making 1 call to base::import |
| 26 | |||||
| 27 | 2 | 28µs | 2 | 14µs | # spent 13µs (12+700ns) within Template::Context::BEGIN@27 which was called:
# once (12µs+700ns) by Template::Config::load at line 27 # spent 13µs making 1 call to Template::Context::BEGIN@27
# spent 700ns making 1 call to Template::Context::__ANON__ |
| 28 | 2 | 21µs | 2 | 7µs | # spent 7µs (6+300ns) within Template::Context::BEGIN@28 which was called:
# once (6µs+300ns) by Template::Config::load at line 28 # spent 7µs making 1 call to Template::Context::BEGIN@28
# spent 300ns making 1 call to Template::Context::__ANON__ |
| 29 | 2 | 25µs | 2 | 64µs | # spent 36µs (9+27) within Template::Context::BEGIN@29 which was called:
# once (9µs+27µs) by Template::Config::load at line 29 # spent 36µs making 1 call to Template::Context::BEGIN@29
# spent 27µs making 1 call to Exporter::import |
| 30 | 2 | 24µs | 2 | 10µs | # spent 10µs (10+400ns) within Template::Context::BEGIN@30 which was called:
# once (10µs+400ns) by Template::Config::load at line 30 # spent 10µs making 1 call to Template::Context::BEGIN@30
# spent 400ns making 1 call to Template::Context::__ANON__ |
| 31 | 2 | 25µs | 2 | 67µs | # spent 37µs (7+30) within Template::Context::BEGIN@31 which was called:
# once (7µs+30µs) by Template::Config::load at line 31 # spent 37µs making 1 call to Template::Context::BEGIN@31
# spent 30µs making 1 call to Exporter::import |
| 32 | |||||
| 33 | 2 | 30µs | 2 | 120µs | # spent 64µs (8+56) within Template::Context::BEGIN@33 which was called:
# once (8µs+56µs) by Template::Config::load at line 33 # spent 64µs making 1 call to Template::Context::BEGIN@33
# spent 56µs making 1 call to constant::import |
| 34 | 2 | 22µs | 2 | 53µs | # spent 29µs (6+24) within Template::Context::BEGIN@34 which was called:
# once (6µs+24µs) by Template::Config::load at line 34 # spent 29µs making 1 call to Template::Context::BEGIN@34
# spent 24µs making 1 call to constant::import |
| 35 | 2 | 3.58ms | 2 | 48µs | # spent 27µs (6+21) within Template::Context::BEGIN@35 which was called:
# once (6µs+21µs) by Template::Config::load at line 35 # spent 27µs making 1 call to Template::Context::BEGIN@35
# spent 21µs making 1 call to constant::import |
| 36 | |||||
| 37 | 1 | 500ns | our $VERSION = 2.98; | ||
| 38 | 1 | 400ns | our $DEBUG = 0 unless defined $DEBUG; | ||
| 39 | 1 | 200ns | our $DEBUG_FORMAT = "\n## \$file line \$line : [% \$text %] ##\n"; | ||
| 40 | 1 | 100ns | our $VIEW_CLASS = 'Template::View'; | ||
| 41 | our $AUTOLOAD; | ||||
| 42 | |||||
| 43 | #======================================================================== | ||||
| 44 | # ----- PUBLIC METHODS ----- | ||||
| 45 | #======================================================================== | ||||
| 46 | |||||
| 47 | #------------------------------------------------------------------------ | ||||
| 48 | # template($name) | ||||
| 49 | # | ||||
| 50 | # General purpose method to fetch a template and return it in compiled | ||||
| 51 | # form. In the usual case, the $name parameter will be a simple string | ||||
| 52 | # containing the name of a template (e.g. 'header'). It may also be | ||||
| 53 | # a reference to Template::Document object (or sub-class) or a Perl | ||||
| 54 | # sub-routine. These are considered to be compiled templates and are | ||||
| 55 | # returned intact. Finally, it may be a reference to any other kind | ||||
| 56 | # of valid input source accepted by Template::Provider (e.g. scalar | ||||
| 57 | # ref, glob, IO handle, etc). | ||||
| 58 | # | ||||
| 59 | # Templates may be cached at one of 3 different levels. The internal | ||||
| 60 | # BLOCKS member is a local cache which holds references to all | ||||
| 61 | # template blocks used or imported via PROCESS since the context's | ||||
| 62 | # reset() method was last called. This is checked first and if the | ||||
| 63 | # template is not found, the method then walks down the BLOCKSTACK | ||||
| 64 | # list. This contains references to the block definition tables in | ||||
| 65 | # any enclosing Template::Documents that we're visiting (e.g. we've | ||||
| 66 | # been called via an INCLUDE and we want to access a BLOCK defined in | ||||
| 67 | # the template that INCLUDE'd us). If nothing is defined, then we | ||||
| 68 | # iterate through the LOAD_TEMPLATES providers list as a 'chain of | ||||
| 69 | # responsibility' (see Design Patterns) asking each object to fetch() | ||||
| 70 | # the template if it can. | ||||
| 71 | # | ||||
| 72 | # Returns the compiled template. On error, undef is returned and | ||||
| 73 | # the internal ERROR value (read via error()) is set to contain an | ||||
| 74 | # error message of the form "$name: $error". | ||||
| 75 | #------------------------------------------------------------------------ | ||||
| 76 | |||||
| 77 | # spent 433s (12.7+421) within Template::Context::template which was called 767335 times, avg 565µs/call:
# 384174 times (4.84s+14.7s) by Template::Context::process at line 309, avg 51µs/call
# 383161 times (7.86s+406s) by Template::Service::process at line 68 of Template/Service.pm, avg 1.08ms/call | ||||
| 78 | 767335 | 242ms | my ($self, $name) = @_; | ||
| 79 | 767335 | 179ms | my ($prefix, $blocks, $defblocks, $provider, $template, $error); | ||
| 80 | my ($shortname, $blockname, $providers); | ||||
| 81 | |||||
| 82 | 767335 | 364ms | $self->debug("template($name)") if $self->{ DEBUG }; | ||
| 83 | |||||
| 84 | # references to Template::Document (or sub-class) objects, or | ||||
| 85 | # CODE references are assumed to be pre-compiled templates and are | ||||
| 86 | # returned intact | ||||
| 87 | 767335 | 10.1s | 1150496 | 2.30s | return $name # spent 1.23s making 767335 calls to Scalar::Util::blessed, avg 2µs/call
# spent 1.06s making 383161 calls to UNIVERSAL::isa, avg 3µs/call |
| 88 | if (blessed($name) && $name->isa(DOCUMENT)) | ||||
| 89 | || ref($name) eq 'CODE'; | ||||
| 90 | |||||
| 91 | 384174 | 133ms | $shortname = $name; | ||
| 92 | |||||
| 93 | 384174 | 181ms | unless (ref $name) { | ||
| 94 | |||||
| 95 | 1013 | 521µs | $self->debug("looking for block [$name]") if $self->{ DEBUG }; | ||
| 96 | |||||
| 97 | # we first look in the BLOCKS hash for a BLOCK that may have | ||||
| 98 | # been imported from a template (via PROCESS) | ||||
| 99 | return $template | ||||
| 100 | 1013 | 1.55ms | if ($template = $self->{ BLOCKS }->{ $name }); | ||
| 101 | |||||
| 102 | # then we iterate through the BLKSTACK list to see if any of the | ||||
| 103 | # Template::Documents we're visiting define this BLOCK | ||||
| 104 | 1013 | 1.75ms | foreach $blocks (@{ $self->{ BLKSTACK } }) { | ||
| 105 | return $template | ||||
| 106 | 1013 | 716µs | if $blocks && ($template = $blocks->{ $name }); | ||
| 107 | } | ||||
| 108 | |||||
| 109 | # now it's time to ask the providers, so we look to see if any | ||||
| 110 | # prefix is specified to indicate the desired provider set. | ||||
| 111 | 1013 | 2.22ms | if ($^O eq 'MSWin32') { | ||
| 112 | # let C:/foo through | ||||
| 113 | $prefix = $1 if $shortname =~ s/^(\w{2,})://o; | ||||
| 114 | } | ||||
| 115 | else { | ||||
| 116 | 1013 | 12.3ms | 1013 | 1.50ms | $prefix = $1 if $shortname =~ s/^(\w+)://; # spent 1.50ms making 1013 calls to Template::Context::CORE:subst, avg 1µs/call |
| 117 | } | ||||
| 118 | |||||
| 119 | 1013 | 584µs | if (defined $prefix) { | ||
| 120 | $providers = $self->{ PREFIX_MAP }->{ $prefix } | ||||
| 121 | || return $self->throw( Template::Constants::ERROR_FILE, | ||||
| 122 | "no providers for template prefix '$prefix'"); | ||||
| 123 | } | ||||
| 124 | } | ||||
| 125 | $providers = $self->{ PREFIX_MAP }->{ default } | ||||
| 126 | || $self->{ LOAD_TEMPLATES } | ||||
| 127 | 384174 | 608ms | unless $providers; | ||
| 128 | |||||
| 129 | |||||
| 130 | # Finally we try the regular template providers which will | ||||
| 131 | # handle references to files, text, etc., as well as templates | ||||
| 132 | # reference by name. If | ||||
| 133 | |||||
| 134 | 384174 | 254ms | $blockname = ''; | ||
| 135 | 384174 | 240ms | while ($shortname) { | ||
| 136 | $self->debug("asking providers for [$shortname] [$blockname]") | ||||
| 137 | 384174 | 229ms | if $self->{ DEBUG }; | ||
| 138 | |||||
| 139 | 384174 | 354ms | foreach my $provider (@$providers) { | ||
| 140 | 384174 | 1.21s | 384174 | 418s | ($template, $error) = $provider->fetch($shortname, $prefix); # spent 418s making 384174 calls to Template::Provider::fetch, avg 1.09ms/call |
| 141 | 384174 | 302ms | if ($error) { | ||
| 142 | if ($error == Template::Constants::STATUS_ERROR) { | ||||
| 143 | # $template contains exception object | ||||
| 144 | if (blessed($template) && $template->isa(EXCEPTION) | ||||
| 145 | && $template->type eq Template::Constants::ERROR_FILE) { | ||||
| 146 | $self->throw($template); | ||||
| 147 | } | ||||
| 148 | else { | ||||
| 149 | $self->throw( Template::Constants::ERROR_FILE, $template ); | ||||
| 150 | } | ||||
| 151 | } | ||||
| 152 | # DECLINE is ok, carry on | ||||
| 153 | } | ||||
| 154 | elsif (length $blockname) { | ||||
| 155 | return $template | ||||
| 156 | if $template = $template->blocks->{ $blockname }; | ||||
| 157 | } | ||||
| 158 | else { | ||||
| 159 | 384174 | 2.17s | return $template; | ||
| 160 | } | ||||
| 161 | } | ||||
| 162 | |||||
| 163 | last if ref $shortname || ! $self->{ EXPOSE_BLOCKS }; | ||||
| 164 | $shortname =~ s{/([^/]+)$}{} || last; | ||||
| 165 | $blockname = length $blockname ? "$1/$blockname" : $1; | ||||
| 166 | } | ||||
| 167 | |||||
| 168 | $self->throw(Template::Constants::ERROR_FILE, "$name: not found"); | ||||
| 169 | } | ||||
| 170 | |||||
| 171 | |||||
| 172 | #------------------------------------------------------------------------ | ||||
| 173 | # plugin($name, \@args) | ||||
| 174 | # | ||||
| 175 | # Calls on each of the LOAD_PLUGINS providers in turn to fetch() (i.e. load | ||||
| 176 | # and instantiate) a plugin of the specified name. Additional parameters | ||||
| 177 | # passed are propagated to the new() constructor for the plugin. | ||||
| 178 | # Returns a reference to a new plugin object or other reference. On | ||||
| 179 | # error, undef is returned and the appropriate error message is set for | ||||
| 180 | # subsequent retrieval via error(). | ||||
| 181 | #------------------------------------------------------------------------ | ||||
| 182 | |||||
| 183 | sub plugin { | ||||
| 184 | my ($self, $name, $args) = @_; | ||||
| 185 | my ($provider, $plugin, $error); | ||||
| 186 | |||||
| 187 | $self->debug("plugin($name, ", defined $args ? @$args : '[ ]', ')') | ||||
| 188 | if $self->{ DEBUG }; | ||||
| 189 | |||||
| 190 | # request the named plugin from each of the LOAD_PLUGINS providers in turn | ||||
| 191 | foreach my $provider (@{ $self->{ LOAD_PLUGINS } }) { | ||||
| 192 | ($plugin, $error) = $provider->fetch($name, $args, $self); | ||||
| 193 | return $plugin unless $error; | ||||
| 194 | if ($error == Template::Constants::STATUS_ERROR) { | ||||
| 195 | $self->throw($plugin) if ref $plugin; | ||||
| 196 | $self->throw(Template::Constants::ERROR_PLUGIN, $plugin); | ||||
| 197 | } | ||||
| 198 | } | ||||
| 199 | |||||
| 200 | $self->throw(Template::Constants::ERROR_PLUGIN, "$name: plugin not found"); | ||||
| 201 | } | ||||
| 202 | |||||
| 203 | |||||
| 204 | #------------------------------------------------------------------------ | ||||
| 205 | # filter($name, \@args, $alias) | ||||
| 206 | # | ||||
| 207 | # Similar to plugin() above, but querying the LOAD_FILTERS providers to | ||||
| 208 | # return filter instances. An alias may be provided which is used to | ||||
| 209 | # save the returned filter in a local cache. | ||||
| 210 | #------------------------------------------------------------------------ | ||||
| 211 | |||||
| 212 | sub filter { | ||||
| 213 | my ($self, $name, $args, $alias) = @_; | ||||
| 214 | my ($provider, $filter, $error); | ||||
| 215 | |||||
| 216 | $self->debug("filter($name, ", | ||||
| 217 | defined $args ? @$args : '[ ]', | ||||
| 218 | defined $alias ? $alias : '<no alias>', ')') | ||||
| 219 | if $self->{ DEBUG }; | ||||
| 220 | |||||
| 221 | # use any cached version of the filter if no params provided | ||||
| 222 | return $filter | ||||
| 223 | if ! $args && ! ref $name | ||||
| 224 | && ($filter = $self->{ FILTER_CACHE }->{ $name }); | ||||
| 225 | |||||
| 226 | # request the named filter from each of the FILTERS providers in turn | ||||
| 227 | foreach my $provider (@{ $self->{ LOAD_FILTERS } }) { | ||||
| 228 | ($filter, $error) = $provider->fetch($name, $args, $self); | ||||
| 229 | last unless $error; | ||||
| 230 | if ($error == Template::Constants::STATUS_ERROR) { | ||||
| 231 | $self->throw($filter) if ref $filter; | ||||
| 232 | $self->throw(Template::Constants::ERROR_FILTER, $filter); | ||||
| 233 | } | ||||
| 234 | # return $self->error($filter) | ||||
| 235 | # if $error == &Template::Constants::STATUS_ERROR; | ||||
| 236 | } | ||||
| 237 | |||||
| 238 | return $self->error("$name: filter not found") | ||||
| 239 | unless $filter; | ||||
| 240 | |||||
| 241 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||||
| 242 | # commented out by abw on 19 Nov 2001 to fix problem with xmlstyle | ||||
| 243 | # plugin which may re-define a filter by calling define_filter() | ||||
| 244 | # multiple times. With the automatic aliasing/caching below, any | ||||
| 245 | # new filter definition isn't seen. Don't think this will cause | ||||
| 246 | # any problems as filters explicitly supplied with aliases will | ||||
| 247 | # still work as expected. | ||||
| 248 | # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||||
| 249 | # alias defaults to name if undefined | ||||
| 250 | # $alias = $name | ||||
| 251 | # unless defined($alias) or ref($name) or $args; | ||||
| 252 | |||||
| 253 | # cache FILTER if alias is valid | ||||
| 254 | $self->{ FILTER_CACHE }->{ $alias } = $filter | ||||
| 255 | if $alias; | ||||
| 256 | |||||
| 257 | return $filter; | ||||
| 258 | } | ||||
| 259 | |||||
| 260 | |||||
| 261 | #------------------------------------------------------------------------ | ||||
| 262 | # view(\%config) | ||||
| 263 | # | ||||
| 264 | # Create a new Template::View bound to this context. | ||||
| 265 | #------------------------------------------------------------------------ | ||||
| 266 | |||||
| 267 | sub view { | ||||
| 268 | my $self = shift; | ||||
| 269 | require Template::View; | ||||
| 270 | return $VIEW_CLASS->new($self, @_) | ||||
| 271 | || $self->throw(&Template::Constants::ERROR_VIEW, | ||||
| 272 | $VIEW_CLASS->error); | ||||
| 273 | } | ||||
| 274 | |||||
| 275 | |||||
| 276 | #------------------------------------------------------------------------ | ||||
| 277 | # process($template, \%params) [% PROCESS template var=val ... %] | ||||
| 278 | # process($template, \%params, $local) [% INCLUDE template var=val ... %] | ||||
| 279 | # | ||||
| 280 | # Processes the template named or referenced by the first parameter. | ||||
| 281 | # The optional second parameter may reference a hash array of variable | ||||
| 282 | # definitions. These are set before the template is processed by | ||||
| 283 | # calling update() on the stash. Note that, unless the third parameter | ||||
| 284 | # is true, the context is not localised and these, and any other | ||||
| 285 | # variables set in the template will retain their new values after this | ||||
| 286 | # method returns. The third parameter is in place so that this method | ||||
| 287 | # can handle INCLUDE calls: the stash will be localized. | ||||
| 288 | # | ||||
| 289 | # Returns the output of processing the template. Errors are thrown | ||||
| 290 | # as Template::Exception objects via die(). | ||||
| 291 | #------------------------------------------------------------------------ | ||||
| 292 | |||||
| 293 | # spent 2133s (28.5+2105) within Template::Context::process which was called 384174 times, avg 5.55ms/call:
# 383161 times (28.4s+2105s) by Template::Service::process at line 94 of Template/Service.pm, avg 5.57ms/call
# 1013 times (140ms+-140ms) by Template::Context::include at line 409, avg 0s/call | ||||
| 294 | 384174 | 285ms | my ($self, $template, $params, $localize) = @_; | ||
| 295 | 384174 | 759ms | my ($trim, $blocks) = @$self{ qw( TRIM BLOCKS ) }; | ||
| 296 | 384174 | 161ms | my (@compiled, $name, $compiled); | ||
| 297 | my ($stash, $component, $tblocks, $error, $tmpout); | ||||
| 298 | 384174 | 280ms | my $output = ''; | ||
| 299 | |||||
| 300 | 384174 | 488ms | $template = [ $template ] unless ref $template eq 'ARRAY'; | ||
| 301 | |||||
| 302 | $self->debug("process([ ", join(', '), @$template, ' ], ', | ||||
| 303 | defined $params ? $params : '<no params>', ', ', | ||||
| 304 | $localize ? '<localized>' : '<unlocalized>', ')') | ||||
| 305 | 384174 | 293ms | if $self->{ DEBUG }; | ||
| 306 | |||||
| 307 | # fetch compiled template for each name specified | ||||
| 308 | 384174 | 397ms | foreach $name (@$template) { | ||
| 309 | 384174 | 885ms | 384174 | 19.6s | push(@compiled, $self->template($name)); # spent 19.6s making 384174 calls to Template::Context::template, avg 51µs/call |
| 310 | } | ||||
| 311 | |||||
| 312 | 384174 | 226ms | 1013 | 53.3ms | if ($localize) { # spent 53.3ms making 1013 calls to Template::Stash::clone, avg 53µs/call |
| 313 | # localise the variable stash with any parameters passed | ||||
| 314 | $stash = $self->{ STASH } = $self->{ STASH }->clone($params); | ||||
| 315 | } else { | ||||
| 316 | # update stash with any new parameters passed | ||||
| 317 | 383161 | 1.34s | 383161 | 2.60s | $self->{ STASH }->update($params); # spent 2.60s making 383161 calls to Template::Stash::update, avg 7µs/call |
| 318 | 383161 | 186ms | $stash = $self->{ STASH }; | ||
| 319 | } | ||||
| 320 | |||||
| 321 | 384174 | 208ms | eval { | ||
| 322 | # save current component | ||||
| 323 | 768348 | 6.73s | 767335 | 8.50s | eval { $component = $stash->get('component') }; # spent 7.01s making 384174 calls to Template::Stash::XS::get, avg 18µs/call
# spent 1.48s making 383161 calls to Template::Stash::undefined, avg 4µs/call |
| 324 | |||||
| 325 | 384174 | 419ms | foreach $name (@$template) { | ||
| 326 | 384174 | 181ms | $compiled = shift @compiled; | ||
| 327 | 384174 | 410ms | my $element = ref $compiled eq 'CODE' | ||
| 328 | ? { (name => (ref $name ? '' : $name), modtime => time()) } | ||||
| 329 | : $compiled; | ||||
| 330 | |||||
| 331 | 384174 | 1.64s | 385187 | 179ms | if (blessed($component) && $component->isa(DOCUMENT)) { # spent 177ms making 384174 calls to Scalar::Util::blessed, avg 460ns/call
# spent 2.66ms making 1013 calls to UNIVERSAL::isa, avg 3µs/call |
| 332 | 1013 | 2.23ms | $element->{ caller } = $component->{ name }; | ||
| 333 | 1013 | 2.42ms | $element->{ callers } = $component->{ callers } || []; | ||
| 334 | 1013 | 1.90ms | push(@{$element->{ callers }}, $element->{ caller }); | ||
| 335 | } | ||||
| 336 | |||||
| 337 | 384174 | 4.08s | 384174 | 1.85s | $stash->set('component', $element); # spent 1.85s making 384174 calls to Template::Stash::XS::set, avg 5µs/call |
| 338 | |||||
| 339 | 384174 | 4.70s | 1149483 | 1.23s | unless ($localize) { # spent 733ms making 383161 calls to Template::Document::blocks, avg 2µs/call
# spent 306ms making 383161 calls to Scalar::Util::blessed, avg 799ns/call
# spent 186ms making 383161 calls to UNIVERSAL::isa, avg 486ns/call |
| 340 | # merge any local blocks defined in the Template::Document | ||||
| 341 | # into our local BLOCKS cache | ||||
| 342 | @$blocks{ keys %$tblocks } = values %$tblocks | ||||
| 343 | if (blessed($compiled) && $compiled->isa(DOCUMENT)) | ||||
| 344 | && ($tblocks = $compiled->blocks); | ||||
| 345 | } | ||||
| 346 | |||||
| 347 | 384174 | 1.74s | 384174 | 2133s | if (ref $compiled eq 'CODE') { # spent 41878s making 384174 calls to Template::Document::process, avg 109ms/call, recursion: max depth 41, sum of overlapping time 39745s |
| 348 | $tmpout = &$compiled($self); | ||||
| 349 | } | ||||
| 350 | elsif (ref $compiled) { | ||||
| 351 | $tmpout = $compiled->process($self); | ||||
| 352 | } | ||||
| 353 | else { | ||||
| 354 | $self->throw('file', | ||||
| 355 | "invalid template reference: $compiled"); | ||||
| 356 | } | ||||
| 357 | |||||
| 358 | 384174 | 174ms | if ($trim) { | ||
| 359 | for ($tmpout) { | ||||
| 360 | s/^\s+//; | ||||
| 361 | s/\s+$//; | ||||
| 362 | } | ||||
| 363 | } | ||||
| 364 | 384174 | 224ms | $output .= $tmpout; | ||
| 365 | |||||
| 366 | # pop last item from callers. | ||||
| 367 | # NOTE - this will not be called if template throws an | ||||
| 368 | # error. The whole issue of caller and callers should be | ||||
| 369 | # revisited to try and avoid putting this info directly into | ||||
| 370 | # the component data structure. Perhaps use a local element | ||||
| 371 | # instead? | ||||
| 372 | |||||
| 373 | 384174 | 2.04s | 385187 | 215ms | pop(@{$element->{ callers }}) # spent 214ms making 384174 calls to Scalar::Util::blessed, avg 558ns/call
# spent 786µs making 1013 calls to UNIVERSAL::isa, avg 776ns/call |
| 374 | if (blessed($component) && $component->isa(DOCUMENT)); | ||||
| 375 | } | ||||
| 376 | 384174 | 3.49s | 384174 | 1.52s | $stash->set('component', $component); # spent 1.52s making 384174 calls to Template::Stash::XS::set, avg 4µs/call |
| 377 | }; | ||||
| 378 | 384174 | 150ms | $error = $@; | ||
| 379 | |||||
| 380 | 384174 | 143ms | 1013 | 1.77ms | if ($localize) { # spent 1.77ms making 1013 calls to Template::Stash::declone, avg 2µs/call |
| 381 | # ensure stash is delocalised before dying | ||||
| 382 | $self->{ STASH } = $self->{ STASH }->declone(); | ||||
| 383 | } | ||||
| 384 | |||||
| 385 | 384174 | 152ms | $self->throw(ref $error | ||
| 386 | ? $error : (Template::Constants::ERROR_FILE, $error)) | ||||
| 387 | if $error; | ||||
| 388 | |||||
| 389 | 384174 | 1.96s | 1013 | 509µs | return $output; # spent 509µs making 1013 calls to Template::Stash::XS::DESTROY, avg 503ns/call |
| 390 | } | ||||
| 391 | |||||
| 392 | |||||
| 393 | #------------------------------------------------------------------------ | ||||
| 394 | # include($template, \%params) [% INCLUDE template var = val, ... %] | ||||
| 395 | # | ||||
| 396 | # Similar to process() above but processing the template in a local | ||||
| 397 | # context. Any variables passed by reference to a hash as the second | ||||
| 398 | # parameter will be set before the template is processed and then | ||||
| 399 | # revert to their original values before the method returns. Similarly, | ||||
| 400 | # any changes made to non-global variables within the template will | ||||
| 401 | # persist only until the template is processed. | ||||
| 402 | # | ||||
| 403 | # Returns the output of processing the template. Errors are thrown | ||||
| 404 | # as Template::Exception objects via die(). | ||||
| 405 | #------------------------------------------------------------------------ | ||||
| 406 | |||||
| 407 | # spent 1557s (28.4ms+1557) within Template::Context::include which was called 1013 times, avg 1.54s/call:
# 998 times (28.2ms+1556s) by Template::Document::__ANON__[input text:9] at line 1 of /root/tor-browser-build/input text, avg 1.56s/call
# 15 times (159µs+1.23s) by Template::Document::__ANON__[input text:35] at line 15 of /root/tor-browser-build/input text, avg 82.3ms/call | ||||
| 408 | 1013 | 2.46ms | my ($self, $template, $params) = @_; | ||
| 409 | 1013 | 16.0ms | 1013 | 0s | return $self->process($template, $params, 'localize me!'); # spent 1721s making 1013 calls to Template::Context::process, avg 1.70s/call, recursion: max depth 39, sum of overlapping time 1721s |
| 410 | } | ||||
| 411 | |||||
| 412 | #------------------------------------------------------------------------ | ||||
| 413 | # insert($file) | ||||
| 414 | # | ||||
| 415 | # Insert the contents of a file without parsing. | ||||
| 416 | #------------------------------------------------------------------------ | ||||
| 417 | |||||
| 418 | sub insert { | ||||
| 419 | my ($self, $file) = @_; | ||||
| 420 | my ($prefix, $providers, $text, $error); | ||||
| 421 | my $output = ''; | ||||
| 422 | |||||
| 423 | my $files = ref $file eq 'ARRAY' ? $file : [ $file ]; | ||||
| 424 | |||||
| 425 | $self->debug("insert([ ", join(', '), @$files, " ])") | ||||
| 426 | if $self->{ DEBUG }; | ||||
| 427 | |||||
| 428 | |||||
| 429 | FILE: foreach $file (@$files) { | ||||
| 430 | my $name = $file; | ||||
| 431 | |||||
| 432 | if ($^O eq 'MSWin32') { | ||||
| 433 | # let C:/foo through | ||||
| 434 | $prefix = $1 if $name =~ s/^(\w{2,})://o; | ||||
| 435 | } | ||||
| 436 | else { | ||||
| 437 | $prefix = $1 if $name =~ s/^(\w+)://; | ||||
| 438 | } | ||||
| 439 | |||||
| 440 | if (defined $prefix) { | ||||
| 441 | $providers = $self->{ PREFIX_MAP }->{ $prefix } | ||||
| 442 | || return $self->throw(Template::Constants::ERROR_FILE, | ||||
| 443 | "no providers for file prefix '$prefix'"); | ||||
| 444 | } | ||||
| 445 | else { | ||||
| 446 | $providers = $self->{ PREFIX_MAP }->{ default } | ||||
| 447 | || $self->{ LOAD_TEMPLATES }; | ||||
| 448 | } | ||||
| 449 | |||||
| 450 | foreach my $provider (@$providers) { | ||||
| 451 | ($text, $error) = $provider->load($name, $prefix); | ||||
| 452 | next FILE unless $error; | ||||
| 453 | if ($error == Template::Constants::STATUS_ERROR) { | ||||
| 454 | $self->throw($text) if ref $text; | ||||
| 455 | $self->throw(Template::Constants::ERROR_FILE, $text); | ||||
| 456 | } | ||||
| 457 | } | ||||
| 458 | $self->throw(Template::Constants::ERROR_FILE, "$file: not found"); | ||||
| 459 | } | ||||
| 460 | continue { | ||||
| 461 | $output .= $text; | ||||
| 462 | } | ||||
| 463 | return $output; | ||||
| 464 | } | ||||
| 465 | |||||
| 466 | |||||
| 467 | #------------------------------------------------------------------------ | ||||
| 468 | # throw($type, $info, \$output) [% THROW errtype "Error info" %] | ||||
| 469 | # | ||||
| 470 | # Throws a Template::Exception object by calling die(). This method | ||||
| 471 | # may be passed a reference to an existing Template::Exception object; | ||||
| 472 | # a single value containing an error message which is used to | ||||
| 473 | # instantiate a Template::Exception of type 'undef'; or a pair of | ||||
| 474 | # values representing the exception type and info from which a | ||||
| 475 | # Template::Exception object is instantiated. e.g. | ||||
| 476 | # | ||||
| 477 | # $context->throw($exception); | ||||
| 478 | # $context->throw("I'm sorry Dave, I can't do that"); | ||||
| 479 | # $context->throw('denied', "I'm sorry Dave, I can't do that"); | ||||
| 480 | # | ||||
| 481 | # An optional third parameter can be supplied in the last case which | ||||
| 482 | # is a reference to the current output buffer containing the results | ||||
| 483 | # of processing the template up to the point at which the exception | ||||
| 484 | # was thrown. The RETURN and STOP directives, for example, use this | ||||
| 485 | # to propagate output back to the user, but it can safely be ignored | ||||
| 486 | # in most cases. | ||||
| 487 | # | ||||
| 488 | # This method rides on a one-way ticket to die() oblivion. It does not | ||||
| 489 | # return in any real sense of the word, but should get caught by a | ||||
| 490 | # surrounding eval { } block (e.g. a BLOCK or TRY) and handled | ||||
| 491 | # accordingly, or returned to the caller as an uncaught exception. | ||||
| 492 | #------------------------------------------------------------------------ | ||||
| 493 | |||||
| 494 | sub throw { | ||||
| 495 | my ($self, $error, $info, $output) = @_; | ||||
| 496 | local $" = ', '; | ||||
| 497 | |||||
| 498 | # die! die! die! | ||||
| 499 | if (blessed($error) && $error->isa(EXCEPTION)) { | ||||
| 500 | die $error; | ||||
| 501 | } | ||||
| 502 | elsif (blessed($error) && $error->isa(BADGER_EXCEPTION)) { | ||||
| 503 | # convert a Badger::Exception to a Template::Exception so that | ||||
| 504 | # things continue to work during the transition to Badger | ||||
| 505 | die EXCEPTION->new($error->type, $error->info); | ||||
| 506 | } | ||||
| 507 | elsif (defined $info) { | ||||
| 508 | die (EXCEPTION->new($error, $info, $output)); | ||||
| 509 | } | ||||
| 510 | else { | ||||
| 511 | $error ||= ''; | ||||
| 512 | die (EXCEPTION->new('undef', $error, $output)); | ||||
| 513 | } | ||||
| 514 | |||||
| 515 | # not reached | ||||
| 516 | } | ||||
| 517 | |||||
| 518 | |||||
| 519 | #------------------------------------------------------------------------ | ||||
| 520 | # catch($error, \$output) | ||||
| 521 | # | ||||
| 522 | # Called by various directives after catching an error thrown via die() | ||||
| 523 | # from within an eval { } block. The first parameter contains the error | ||||
| 524 | # which may be a sanitized reference to a Template::Exception object | ||||
| 525 | # (such as that raised by the throw() method above, a plugin object, | ||||
| 526 | # and so on) or an error message thrown via die from somewhere in user | ||||
| 527 | # code. The latter are coerced into 'undef' Template::Exception objects. | ||||
| 528 | # Like throw() above, a reference to a scalar may be passed as an | ||||
| 529 | # additional parameter to represent the current output buffer | ||||
| 530 | # localised within the eval block. As exceptions are thrown upwards | ||||
| 531 | # and outwards from nested blocks, the catch() method reconstructs the | ||||
| 532 | # correct output buffer from these fragments, storing it in the | ||||
| 533 | # exception object for passing further onwards and upwards. | ||||
| 534 | # | ||||
| 535 | # Returns a reference to a Template::Exception object.. | ||||
| 536 | #------------------------------------------------------------------------ | ||||
| 537 | |||||
| 538 | sub catch { | ||||
| 539 | my ($self, $error, $output) = @_; | ||||
| 540 | |||||
| 541 | if ( blessed($error) | ||||
| 542 | && ( $error->isa(EXCEPTION) || $error->isa(BADGER_EXCEPTION) ) ) { | ||||
| 543 | $error->text($output) if $output; | ||||
| 544 | return $error; | ||||
| 545 | } | ||||
| 546 | else { | ||||
| 547 | return EXCEPTION->new('undef', $error, $output); | ||||
| 548 | } | ||||
| 549 | } | ||||
| 550 | |||||
| 551 | |||||
| 552 | #------------------------------------------------------------------------ | ||||
| 553 | # localise(\%params) | ||||
| 554 | # delocalise() | ||||
| 555 | # | ||||
| 556 | # The localise() method creates a local copy of the current stash, | ||||
| 557 | # allowing the existing state of variables to be saved and later | ||||
| 558 | # restored via delocalise(). | ||||
| 559 | # | ||||
| 560 | # A reference to a hash array may be passed containing local variable | ||||
| 561 | # definitions which should be added to the cloned namespace. These | ||||
| 562 | # values persist until delocalisation. | ||||
| 563 | #------------------------------------------------------------------------ | ||||
| 564 | |||||
| 565 | # spent 12.2s (3.30+8.92) within Template::Context::localise which was called 383161 times, avg 32µs/call:
# 383161 times (3.30s+8.92s) by Template::Service::process at line 78 of Template/Service.pm, avg 32µs/call | ||||
| 566 | 383161 | 228ms | my $self = shift; | ||
| 567 | 383161 | 3.09s | 383161 | 8.92s | $self->{ STASH } = $self->{ STASH }->clone(@_); # spent 8.92s making 383161 calls to Template::Stash::clone, avg 23µs/call |
| 568 | } | ||||
| 569 | |||||
| 570 | # spent 7.88s (6.17+1.71) within Template::Context::delocalise which was called 383161 times, avg 21µs/call:
# 383161 times (6.17s+1.71s) by Template::Service::process at line 124 of Template/Service.pm, avg 21µs/call | ||||
| 571 | 383161 | 151ms | my $self = shift; | ||
| 572 | 383161 | 5.52s | 766322 | 1.71s | $self->{ STASH } = $self->{ STASH }->declone(); # spent 1.08s making 383161 calls to Template::Stash::declone, avg 3µs/call
# spent 632ms making 383161 calls to Template::Stash::XS::DESTROY, avg 2µs/call |
| 573 | } | ||||
| 574 | |||||
| 575 | |||||
| 576 | #------------------------------------------------------------------------ | ||||
| 577 | # visit($document, $blocks) | ||||
| 578 | # | ||||
| 579 | # Each Template::Document calls the visit() method on the context | ||||
| 580 | # before processing itself. It passes a reference to the hash array | ||||
| 581 | # of named BLOCKs defined within the document, allowing them to be | ||||
| 582 | # added to the internal BLKSTACK list which is subsequently used by | ||||
| 583 | # template() to resolve templates. | ||||
| 584 | # from a provider. | ||||
| 585 | #------------------------------------------------------------------------ | ||||
| 586 | |||||
| 587 | # spent 1.29s within Template::Context::visit which was called 384174 times, avg 3µs/call:
# 384174 times (1.29s+0s) by Template::Document::process at line 158 of Template/Document.pm, avg 3µs/call | ||||
| 588 | 384174 | 214ms | my ($self, $document, $blocks) = @_; | ||
| 589 | 384174 | 2.46s | unshift(@{ $self->{ BLKSTACK } }, $blocks) | ||
| 590 | } | ||||
| 591 | |||||
| 592 | |||||
| 593 | #------------------------------------------------------------------------ | ||||
| 594 | # leave() | ||||
| 595 | # | ||||
| 596 | # The leave() method is called when the document has finished | ||||
| 597 | # processing itself. This removes the entry from the BLKSTACK list | ||||
| 598 | # that was added visit() above. For persistence of BLOCK definitions, | ||||
| 599 | # the process() method (i.e. the PROCESS directive) does some extra | ||||
| 600 | # magic to copy BLOCKs into a shared hash. | ||||
| 601 | #------------------------------------------------------------------------ | ||||
| 602 | |||||
| 603 | # spent 967ms within Template::Context::leave which was called 384174 times, avg 3µs/call:
# 384174 times (967ms+0s) by Template::Document::process at line 167 of Template/Document.pm, avg 3µs/call | ||||
| 604 | 384174 | 165ms | my $self = shift; | ||
| 605 | 384174 | 1.82s | shift(@{ $self->{ BLKSTACK } }); | ||
| 606 | } | ||||
| 607 | |||||
| 608 | |||||
| 609 | #------------------------------------------------------------------------ | ||||
| 610 | # define_block($name, $block) | ||||
| 611 | # | ||||
| 612 | # Adds a new BLOCK definition to the local BLOCKS cache. $block may | ||||
| 613 | # be specified as a reference to a sub-routine or Template::Document | ||||
| 614 | # object or as text which is compiled into a template. Returns a true | ||||
| 615 | # value (the $block reference or compiled block reference) if | ||||
| 616 | # successful or undef on failure. Call error() to retrieve the | ||||
| 617 | # relevant error message (i.e. compilation failure). | ||||
| 618 | #------------------------------------------------------------------------ | ||||
| 619 | |||||
| 620 | sub define_block { | ||||
| 621 | my ($self, $name, $block) = @_; | ||||
| 622 | $block = $self->template(\$block) | ||||
| 623 | || return undef | ||||
| 624 | unless ref $block; | ||||
| 625 | $self->{ BLOCKS }->{ $name } = $block; | ||||
| 626 | } | ||||
| 627 | |||||
| 628 | |||||
| 629 | #------------------------------------------------------------------------ | ||||
| 630 | # define_filter($name, $filter, $is_dynamic) | ||||
| 631 | # | ||||
| 632 | # Adds a new FILTER definition to the local FILTER_CACHE. | ||||
| 633 | #------------------------------------------------------------------------ | ||||
| 634 | |||||
| 635 | sub define_filter { | ||||
| 636 | my ($self, $name, $filter, $is_dynamic) = @_; | ||||
| 637 | my ($result, $error); | ||||
| 638 | $filter = [ $filter, 1 ] if $is_dynamic; | ||||
| 639 | |||||
| 640 | foreach my $provider (@{ $self->{ LOAD_FILTERS } }) { | ||||
| 641 | ($result, $error) = $provider->store($name, $filter); | ||||
| 642 | return 1 unless $error; | ||||
| 643 | $self->throw(&Template::Constants::ERROR_FILTER, $result) | ||||
| 644 | if $error == &Template::Constants::STATUS_ERROR; | ||||
| 645 | } | ||||
| 646 | $self->throw(&Template::Constants::ERROR_FILTER, | ||||
| 647 | "FILTER providers declined to store filter $name"); | ||||
| 648 | } | ||||
| 649 | |||||
| 650 | |||||
| 651 | #------------------------------------------------------------------------ | ||||
| 652 | # define_vmethod($type, $name, \&sub) | ||||
| 653 | # | ||||
| 654 | # Passes $type, $name, and &sub on to stash->define_vmethod(). | ||||
| 655 | #------------------------------------------------------------------------ | ||||
| 656 | |||||
| 657 | sub define_vmethod { | ||||
| 658 | my $self = shift; | ||||
| 659 | $self->stash->define_vmethod(@_); | ||||
| 660 | } | ||||
| 661 | |||||
| 662 | |||||
| 663 | #------------------------------------------------------------------------ | ||||
| 664 | # define_view($name, $params) | ||||
| 665 | # | ||||
| 666 | # Defines a new view. | ||||
| 667 | #------------------------------------------------------------------------ | ||||
| 668 | |||||
| 669 | sub define_view { | ||||
| 670 | my ($self, $name, $params) = @_; | ||||
| 671 | my $base; | ||||
| 672 | |||||
| 673 | if (defined $params->{ base }) { | ||||
| 674 | my $base = $self->{ STASH }->get($params->{ base }); | ||||
| 675 | |||||
| 676 | return $self->throw( | ||||
| 677 | &Template::Constants::ERROR_VIEW, | ||||
| 678 | "view base is not defined: $params->{ base }" | ||||
| 679 | ) unless $base; | ||||
| 680 | |||||
| 681 | return $self->throw( | ||||
| 682 | &Template::Constants::ERROR_VIEW, | ||||
| 683 | "view base is not a $VIEW_CLASS object: $params->{ base } => $base" | ||||
| 684 | ) unless blessed($base) && $base->isa($VIEW_CLASS); | ||||
| 685 | |||||
| 686 | $params->{ base } = $base; | ||||
| 687 | } | ||||
| 688 | my $view = $self->view($params); | ||||
| 689 | $view->seal(); | ||||
| 690 | $self->{ STASH }->set($name, $view); | ||||
| 691 | } | ||||
| 692 | |||||
| 693 | |||||
| 694 | #------------------------------------------------------------------------ | ||||
| 695 | # define_views($views) | ||||
| 696 | # | ||||
| 697 | # Defines multiple new views. | ||||
| 698 | #------------------------------------------------------------------------ | ||||
| 699 | |||||
| 700 | sub define_views { | ||||
| 701 | my ($self, $views) = @_; | ||||
| 702 | |||||
| 703 | # a list reference is better because the order is deterministic (and so | ||||
| 704 | # allows an earlier VIEW to be the base for a later VIEW), but we'll | ||||
| 705 | # accept a hash reference and assume that the user knows the order of | ||||
| 706 | # processing is undefined | ||||
| 707 | $views = [ %$views ] | ||||
| 708 | if ref $views eq 'HASH'; | ||||
| 709 | |||||
| 710 | # make of copy so we don't destroy the original list reference | ||||
| 711 | my @items = @$views; | ||||
| 712 | my ($name, $view); | ||||
| 713 | |||||
| 714 | while (@items) { | ||||
| 715 | $self->define_view(splice(@items, 0, 2)); | ||||
| 716 | } | ||||
| 717 | } | ||||
| 718 | |||||
| 719 | |||||
| 720 | #------------------------------------------------------------------------ | ||||
| 721 | # reset() | ||||
| 722 | # | ||||
| 723 | # Reset the state of the internal BLOCKS hash to clear any BLOCK | ||||
| 724 | # definitions imported via the PROCESS directive. Any original | ||||
| 725 | # BLOCKS definitions passed to the constructor will be restored. | ||||
| 726 | #------------------------------------------------------------------------ | ||||
| 727 | |||||
| 728 | # spent 1.71s within Template::Context::reset which was called 383161 times, avg 4µs/call:
# 383161 times (1.71s+0s) by Template::Service::process at line 64 of Template/Service.pm, avg 4µs/call | ||||
| 729 | 383161 | 224ms | my ($self, $blocks) = @_; | ||
| 730 | 383161 | 521ms | $self->{ BLKSTACK } = [ ]; | ||
| 731 | 383161 | 2.11s | $self->{ BLOCKS } = { %{ $self->{ INIT_BLOCKS } } }; | ||
| 732 | } | ||||
| 733 | |||||
| 734 | |||||
| 735 | #------------------------------------------------------------------------ | ||||
| 736 | # stash() | ||||
| 737 | # | ||||
| 738 | # Simple accessor methods to return the STASH values. This is likely | ||||
| 739 | # to be called quite often so we provide a direct method rather than | ||||
| 740 | # relying on the slower AUTOLOAD. | ||||
| 741 | #------------------------------------------------------------------------ | ||||
| 742 | |||||
| 743 |