Profile of Template/Provider.pm

Filename	/usr/lib/x86_64-linux-gnu/perl5/5.28/Template/Provider.pm
Statements	Executed 23789711 statements in 40.0s

Subroutines
Calls	P	F	Exclusive Time	Inclusive Time	Subroutine
375387	1	1	15.1s	15.7s	Template::Provider::::_initTemplate::Provider::_init
376400	2	1	12.3s	391s	Template::Provider::::_compileTemplate::Provider::_compile
376400	1	1	6.25s	402s	Template::Provider::::fetchTemplate::Provider::fetch
376415	2	1	4.05s	4.31s	Template::Provider::::_loadTemplate::Provider::_load
375387	1	1	1.73s	1.73s	Template::Provider::::DESTROYTemplate::Provider::DESTROY
376400	2	1	542ms	542ms	Template::Provider::::CORE:regcompTemplate::Provider::CORE:regcomp (opcode)
3054	2	1	63.2ms	63.2ms	Template::Provider::::CORE:statTemplate::Provider::CORE:stat (opcode)
1013	1	1	42.3ms	117ms	Template::Provider::::_template_contentTemplate::Provider::_template_content
1028	1	1	42.0ms	12.7s	Template::Provider::::_fetchTemplate::Provider::_fetch
1013	1	1	40.6ms	40.6ms	Template::Provider::::CORE:openTemplate::Provider::CORE:open (opcode)
1013	1	1	28.5ms	12.7s	Template::Provider::::_fetch_pathTemplate::Provider::_fetch_path
1013	1	1	28.1ms	77.2ms	Template::Provider::::_storeTemplate::Provider::_store
1013	1	1	25.8ms	107ms	Template::Provider::::_decode_unicodeTemplate::Provider::_decode_unicode
1013	1	1	17.6ms	17.6ms	Template::Provider::::CORE:readlineTemplate::Provider::CORE:readline (opcode)
2041	2	1	16.7ms	77.5ms	Template::Provider::_template_modified
1013	1	1	14.3ms	14.3ms	Template::Provider::::pathsTemplate::Provider::paths
1013	1	1	11.9ms	89.1ms	Template::Provider::::storeTemplate::Provider::store
1013	1	1	10.1ms	49.2ms	Template::Provider::::_modifiedTemplate::Provider::_modified
1013	1	1	8.30ms	8.30ms	Template::Provider::::CORE:closeTemplate::Provider::CORE:close (opcode)
2041	2	1	7.53ms	7.53ms	Template::Provider::_compiled_filename
1028	1	1	6.61ms	12.1ms	Template::Provider::_compiled_is_current
1013	1	1	3.48ms	3.48ms	Template::Provider::::CORE:ftdirTemplate::Provider::CORE:ftdir (opcode)
1013	1	1	2.61ms	2.61ms	Template::Provider::::CORE:binmodeTemplate::Provider::CORE:binmode (opcode)
1	1	1	1.29ms	1.38ms	Template::Provider::::BEGIN@46Template::Provider::BEGIN@46
1013	1	1	1.29ms	1.29ms	Template::Provider::::CORE:matchTemplate::Provider::CORE:match (opcode)
1	1	1	81µs	104µs	Template::Provider::::BEGIN@52Template::Provider::BEGIN@52
1	1	1	13µs	16µs	Template::Provider::::BEGIN@1092Template::Provider::BEGIN@1092
1	1	1	11µs	12µs	Template::Provider::::BEGIN@48Template::Provider::BEGIN@48
1	1	1	10µs	12µs	Template::Provider::::BEGIN@41Template::Provider::BEGIN@41
1	1	1	8µs	9µs	Template::Provider::::BEGIN@44Template::Provider::BEGIN@44
1	1	1	8µs	43µs	Template::Provider::::BEGIN@50Template::Provider::BEGIN@50
1	1	1	7µs	48µs	Template::Provider::::BEGIN@47Template::Provider::BEGIN@47
1	1	1	5µs	16µs	Template::Provider::::BEGIN@45Template::Provider::BEGIN@45
1	1	1	5µs	17µs	Template::Provider::::BEGIN@42Template::Provider::BEGIN@42
1	1	1	4µs	24µs	Template::Provider::::BEGIN@54Template::Provider::BEGIN@54
1	1	1	4µs	48µs	Template::Provider::::BEGIN@43Template::Provider::BEGIN@43
1	1	1	4µs	26µs	Template::Provider::::BEGIN@51Template::Provider::BEGIN@51
1	1	1	4µs	25µs	Template::Provider::::BEGIN@55Template::Provider::BEGIN@55
1	1	1	4µs	25µs	Template::Provider::::BEGIN@53Template::Provider::BEGIN@53
1	1	1	3µs	3µs	Template::Provider::::BEGIN@87Template::Provider::BEGIN@87
1	1	1	2µs	2µs	Template::Provider::::CORE:qrTemplate::Provider::CORE:qr (opcode)
3	3	1	2µs	2µs	Template::Provider::::__ANON__Template::Provider::__ANON__ (xsub)
0	0	0	0s	0s	Template::Provider::::_dumpTemplate::Provider::_dump
0	0	0	0s	0s	Template::Provider::::_dump_cacheTemplate::Provider::_dump_cache
0	0	0	0s	0s	Template::Provider::::_load_compiledTemplate::Provider::_load_compiled
0	0	0	0s	0s	Template::Provider::::_refreshTemplate::Provider::_refresh
0	0	0	0s	0s	Template::Provider::::include_pathTemplate::Provider::include_path
0	0	0	0s	0s	Template::Provider::::loadTemplate::Provider::load

Call graph for these subroutines as a Graphviz dot language file.

Line	State ments	Time on line	Calls	Time in subs	Code
1					#============================================================= --Perl--
2					#
3					# Template::Provider
4					#
5					# DESCRIPTION
6					# This module implements a class which handles the loading, compiling
7					# and caching of templates. Multiple Template::Provider objects can
8					# be stacked and queried in turn to effect a Chain-of-Command between
9					# them. A provider will attempt to return the requested template,
10					# an error (STATUS_ERROR) or decline to provide the template
11					# (STATUS_DECLINE), allowing subsequent providers to attempt to
12					# deliver it. See 'Design Patterns' for further details.
13					#
14					# AUTHORS
15					# Andy Wardley <abw@wardley.org>
16					#
17					# Refactored by Bill Moseley for v2.19 to add negative caching (i.e.
18					# tracking templates that are NOTFOUND so that we can decline quickly)
19					# and to provide better support for subclassing the provider.
20					#
21					# COPYRIGHT
22					# Copyright (C) 1996-2007 Andy Wardley. All Rights Reserved.
23					#
24					# This module is free software; you can redistribute it and/or
25					# modify it under the same terms as Perl itself.
26					#
27					# WARNING:
28					# This code is ugly and contorted and is being totally re-written for TT3.
29					# In particular, we'll be throwing errors rather than messing around
30					# returning (value, status) pairs. With the benefit of hindsight, that
31					# was a really bad design decision on my part. I deserve to be knocked
32					# to the ground and kicked around a bit by hoards of angry TT developers
33					# for that one. Bill's refactoring has made the module easier to subclass,
34					# (so you can ease off the kicking now), but it really needs to be totally
35					# redesigned and rebuilt from the ground up along with the bits of TT that
36					# use it. -- abw 2007/04/27
37					#============================================================================
38
39					package Template::Provider;
40
41	2	18µs	2	14µs	# spent 12µs (10+2) within Template::Provider::BEGIN@41 which was called: # once (10µs+2µs) by Template::BEGIN@29 at line 41 use strict; # spent 12µs making 1 call to Template::Provider::BEGIN@41 # spent 2µs making 1 call to strict::import
42	2	18µs	2	28µs	# spent 17µs (5+12) within Template::Provider::BEGIN@42 which was called: # once (5µs+12µs) by Template::BEGIN@29 at line 42 use warnings; # spent 17µs making 1 call to Template::Provider::BEGIN@42 # spent 12µs making 1 call to warnings::import
43	2	23µs	2	92µs	# spent 48µs (4+44) within Template::Provider::BEGIN@43 which was called: # once (4µs+44µs) by Template::BEGIN@29 at line 43 use base 'Template::Base'; # spent 48µs making 1 call to Template::Provider::BEGIN@43 # spent 44µs making 1 call to base::import
44	2	22µs	2	10µs	# spent 9µs (8+500ns) within Template::Provider::BEGIN@44 which was called: # once (8µs+500ns) by Template::BEGIN@29 at line 44 use Template::Config; # spent 9µs making 1 call to Template::Provider::BEGIN@44 # spent 500ns making 1 call to Template::Provider::__ANON__
45	2	17µs	2	26µs	# spent 16µs (5+10) within Template::Provider::BEGIN@45 which was called: # once (5µs+10µs) by Template::BEGIN@29 at line 45 use Template::Constants; # spent 16µs making 1 call to Template::Provider::BEGIN@45 # spent 10µs making 1 call to Exporter::import
46	2	158µs	2	1.38ms	# spent 1.38ms (1.29+92µs) within Template::Provider::BEGIN@46 which was called: # once (1.29ms+92µs) by Template::BEGIN@29 at line 46 use Template::Document; # spent 1.38ms making 1 call to Template::Provider::BEGIN@46 # spent 1µs making 1 call to Template::Provider::__ANON__
47	2	21µs	2	89µs	# spent 48µs (7+41) within Template::Provider::BEGIN@47 which was called: # once (7µs+41µs) by Template::BEGIN@29 at line 47 use File::Basename; # spent 48µs making 1 call to Template::Provider::BEGIN@47 # spent 41µs making 1 call to Exporter::import
48	2	28µs	2	12µs	# spent 12µs (11+500ns) within Template::Provider::BEGIN@48 which was called: # once (11µs+500ns) by Template::BEGIN@29 at line 48 use File::Spec; # spent 12µs making 1 call to Template::Provider::BEGIN@48 # spent 500ns making 1 call to Template::Provider::__ANON__
49
50	2	22µs	2	78µs	# spent 43µs (8+35) within Template::Provider::BEGIN@50 which was called: # once (8µs+35µs) by Template::BEGIN@29 at line 50 use constant PREV => 0; # spent 43µs making 1 call to Template::Provider::BEGIN@50 # spent 35µs making 1 call to constant::import
51	2	96µs	2	48µs	# spent 26µs (4+22) within Template::Provider::BEGIN@51 which was called: # once (4µs+22µs) by Template::BEGIN@29 at line 51 use constant NAME => 1; # template name -- indexed by this name in LOOKUP # spent 26µs making 1 call to Template::Provider::BEGIN@51 # spent 22µs making 1 call to constant::import
52	2	21µs	2	128µs	# spent 104µs (81+24) within Template::Provider::BEGIN@52 which was called: # once (81µs+24µs) by Template::BEGIN@29 at line 52 use constant DATA => 2; # Compiled template # spent 104µs making 1 call to Template::Provider::BEGIN@52 # spent 24µs making 1 call to constant::import
53	2	19µs	2	45µs	# spent 25µs (4+21) within Template::Provider::BEGIN@53 which was called: # once (4µs+21µs) by Template::BEGIN@29 at line 53 use constant LOAD => 3; # mtime of template # spent 25µs making 1 call to Template::Provider::BEGIN@53 # spent 21µs making 1 call to constant::import
54	2	20µs	2	44µs	# spent 24µs (4+20) within Template::Provider::BEGIN@54 which was called: # once (4µs+20µs) by Template::BEGIN@29 at line 54 use constant NEXT => 4; # link to next item in cache linked list # spent 24µs making 1 call to Template::Provider::BEGIN@54 # spent 20µs making 1 call to constant::import
55	2	182µs	2	45µs	# spent 25µs (4+20) within Template::Provider::BEGIN@55 which was called: # once (4µs+20µs) by Template::BEGIN@29 at line 55 use constant STAT => 5; # Time last stat()ed # spent 25µs making 1 call to Template::Provider::BEGIN@55 # spent 20µs making 1 call to constant::import
56
57	1	300ns			our $VERSION = 2.94;
58	1	200ns			our $DEBUG = 0 unless defined $DEBUG;
59	1	200ns			our $ERROR = '';
60
61					# name of document class
62	1	100ns			our $DOCUMENT = 'Template::Document' unless defined $DOCUMENT;
63
64					# maximum time between performing stat() on file to check staleness
65	1	100ns			our $STAT_TTL = 1 unless defined $STAT_TTL;
66
67					# maximum number of directories in an INCLUDE_PATH, to prevent runaways
68	1	100ns			our $MAX_DIRS = 64 unless defined $MAX_DIRS;
69
70					# UNICODE is supported in versions of Perl from 5.007 onwards
71	1	700ns			our $UNICODE = $] > 5.007 ? 1 : 0;
72
73	1	1µs			my $boms = [
74					'UTF-8' => "\x{ef}\x{bb}\x{bf}",
75					'UTF-32BE' => "\x{0}\x{0}\x{fe}\x{ff}",
76					'UTF-32LE' => "\x{ff}\x{fe}\x{0}\x{0}",
77					'UTF-16BE' => "\x{fe}\x{ff}",
78					'UTF-16LE' => "\x{ff}\x{fe}",
79					];
80
81					# regex to match relative paths
82	1	8µs	1	2µs	our $RELATIVE_PATH = qr[(?:^\|/)\.+/]; # spent 2µs making 1 call to Template::Provider::CORE:qr
83
84
85					# hack so that 'use bytes' will compile on versions of Perl earlier than
86					# 5.6, even though we never call _decode_unicode() on those systems
87					# spent 3µs within Template::Provider::BEGIN@87 which was called: # once (3µs+0s) by Template::BEGIN@29 at line 92 BEGIN {
88	1	4µs			if ($] < 5.006) {
89					package bytes;
90					$INC{'bytes.pm'} = 1;
91					}
92	1	3.76ms	1	3µs	} # spent 3µs making 1 call to Template::Provider::BEGIN@87
93
94
95					#========================================================================
96					# -- PUBLIC METHODS --
97					#========================================================================
98
99					#------------------------------------------------------------------------
100					# fetch($name)
101					#
102					# Returns a compiled template for the name specified by parameter.
103					# The template is returned from the internal cache if it exists, or
104					# loaded and then subsequently cached. The ABSOLUTE and RELATIVE
105					# configuration flags determine if absolute (e.g. '/something...')
106					# and/or relative (e.g. './something') paths should be honoured. The
107					# INCLUDE_PATH is otherwise used to find the named file. $name may
108					# also be a reference to a text string containing the template text,
109					# or a file handle from which the content is read. The compiled
110					# template is not cached in these latter cases given that there is no
111					# filename to cache under. A subsequent call to store($name,
112					# $compiled) can be made to cache the compiled template for future
113					# fetch() calls, if necessary.
114					#
115					# Returns a compiled template or (undef, STATUS_DECLINED) if the
116					# template could not be found. On error (e.g. the file was found
117					# but couldn't be read or parsed), the pair ($error, STATUS_ERROR)
118					# is returned. The TOLERANT configuration option can be set to
119					# downgrade any errors to STATUS_DECLINE.
120					#------------------------------------------------------------------------
121
122					# spent 402s (6.25+396) within Template::Provider::fetch which was called 376400 times, avg 1.07ms/call: # 376400 times (6.25s+396s) by Template::Context::template at line 140 of Template/Context.pm, avg 1.07ms/call sub fetch {
123	376400	215ms			my ($self, $name) = @_;
124	376400	70.4ms			my ($data, $error);
125
126
127	376400	338ms	3039	20.7ms	if (ref $name) { # spent 19.1ms making 1013 calls to File::Spec::Unix::file_name_is_absolute, avg 19µs/call # spent 1.29ms making 1013 calls to Template::Provider::CORE:match, avg 1µs/call # spent 297µs making 1013 calls to Template::Provider::CORE:regcomp, avg 293ns/call
128					# $name can be a reference to a scalar, GLOB or file handle
129	375387	1.17s	375387	4.02s	($data, $error) = $self->_load($name); # spent 4.02s making 375387 calls to Template::Provider::_load, avg 11µs/call
130	375387	1.22s	375387	379s	($data, $error) = $self->_compile($data) # spent 379s making 375387 calls to Template::Provider::_compile, avg 1.01ms/call
131					unless $error;
132					$data = $data->{ data }
133	375387	658ms			unless $error;
134					}
135					elsif (File::Spec->file_name_is_absolute($name)) {
136					# absolute paths (starting '/') allowed if ABSOLUTE set
137					($data, $error) = $self->{ ABSOLUTE }
138					? $self->_fetch($name)
139					: $self->{ TOLERANT }
140					? (undef, Template::Constants::STATUS_DECLINED)
141					: ("$name: absolute paths are not allowed (set ABSOLUTE option)",
142					Template::Constants::STATUS_ERROR);
143					}
144					elsif ($name =~ m/$RELATIVE_PATH/o) {
145					# anything starting "./" is relative to cwd, allowed if RELATIVE set
146					($data, $error) = $self->{ RELATIVE }
147					? $self->_fetch($name)
148					: $self->{ TOLERANT }
149					? (undef, Template::Constants::STATUS_DECLINED)
150					: ("$name: relative paths are not allowed (set RELATIVE option)",
151					Template::Constants::STATUS_ERROR);
152					}
153					else {
154					# otherwise, it's a file name relative to INCLUDE_PATH
155					($data, $error) = $self->{ INCLUDE_PATH }
156	1013	5.29ms	1013	12.7s	? $self->_fetch_path($name) # spent 12.7s making 1013 calls to Template::Provider::_fetch_path, avg 12.6ms/call
157					: (undef, Template::Constants::STATUS_DECLINED);
158					}
159
160					# $self->_dump_cache()
161					# if $DEBUG > 1;
162
163	376400	1.78s			return ($data, $error);
164					}
165
166
167					#------------------------------------------------------------------------
168					# store($name, $data)
169					#
170					# Store a compiled template ($data) in the cached as $name.
171					# Returns compiled template
172					#------------------------------------------------------------------------
173
174					# spent 89.1ms (11.9+77.2) within Template::Provider::store which was called 1013 times, avg 88µs/call: # 1013 times (11.9ms+77.2ms) by Template::Provider::_fetch at line 490, avg 88µs/call sub store {
175	1013	1.13ms			my ($self, $name, $data) = @_;
176	1013	16.2ms	1013	77.2ms	$self->_store($name, { # spent 77.2ms making 1013 calls to Template::Provider::_store, avg 76µs/call
177					data => $data,
178					load => 0,
179					});
180					}
181
182
183					#------------------------------------------------------------------------
184					# load($name)
185					#
186					# Load a template without parsing/compiling it, suitable for use with
187					# the INSERT directive. There's some duplication with fetch() and at
188					# some point this could be reworked to integrate them a little closer.
189					#------------------------------------------------------------------------
190
191					sub load {
192					my ($self, $name) = @_;
193					my ($data, $error);
194					my $path = $name;
195
196					if (File::Spec->file_name_is_absolute($name)) {
197					# absolute paths (starting '/') allowed if ABSOLUTE set
198					$error = "$name: absolute paths are not allowed (set ABSOLUTE option)"
199					unless $self->{ ABSOLUTE };
200					}
201					elsif ($name =~ m[$RELATIVE_PATH]o) {
202					# anything starting "./" is relative to cwd, allowed if RELATIVE set
203					$error = "$name: relative paths are not allowed (set RELATIVE option)"
204					unless $self->{ RELATIVE };
205					}
206					else {
207					INCPATH: {
208					# otherwise, it's a file name relative to INCLUDE_PATH
209					my $paths = $self->paths()
210					\|\| return ($self->error(), Template::Constants::STATUS_ERROR);
211
212					foreach my $dir (@$paths) {
213					$path = File::Spec->catfile($dir, $name);
214					last INCPATH
215					if $self->_template_modified($path);
216					}
217					undef $path; # not found
218					}
219					}
220
221					# Now fetch the content
222					($data, $error) = $self->_template_content($path)
223					if defined $path && !$error;
224
225					if ($error) {
226					return $self->{ TOLERANT }
227					? (undef, Template::Constants::STATUS_DECLINED)
228					: ($error, Template::Constants::STATUS_ERROR);
229					}
230					elsif (! defined $path) {
231					return (undef, Template::Constants::STATUS_DECLINED);
232					}
233					else {
234					return ($data, Template::Constants::STATUS_OK);
235					}
236					}
237
- -
240					#------------------------------------------------------------------------
241					# include_path(\@newpath)
242					#
243					# Accessor method for the INCLUDE_PATH setting. If called with an
244					# argument, this method will replace the existing INCLUDE_PATH with
245					# the new value.
246					#------------------------------------------------------------------------
247
248					sub include_path {
249					my ($self, $path) = @_;
250					$self->{ INCLUDE_PATH } = $path if $path;
251					return $self->{ INCLUDE_PATH };
252					}
253
254
255					#------------------------------------------------------------------------
256					# paths()
257					#
258					# Evaluates the INCLUDE_PATH list, ignoring any blank entries, and
259					# calling and subroutine or object references to return dynamically
260					# generated path lists. Returns a reference to a new list of paths
261					# or undef on error.
262					#------------------------------------------------------------------------
263
264					# spent 14.3ms within Template::Provider::paths which was called 1013 times, avg 14µs/call: # 1013 times (14.3ms+0s) by Template::Provider::_fetch_path at line 520, avg 14µs/call sub paths {
265	1013	480µs			my $self = shift;
266	1013	2.63ms			my @ipaths = @{ $self->{ INCLUDE_PATH } };
267	1013	991µs			my (@opaths, $dpaths, $dir);
268	1013	981µs			my $count = $MAX_DIRS;
269
270	1013	1.37ms			while (@ipaths && --$count) {
271	2026	1.04ms			$dir = shift @ipaths \|\| next;
272
273					# $dir can be a sub or object ref which returns a reference
274					# to a dynamically generated list of search paths.
275
276	2026	1.89ms			if (ref $dir eq 'CODE') {
277					eval { $dpaths = &$dir() };
278					if ($@) {
279					chomp $@;
280					return $self->error($@);
281					}
282					unshift(@ipaths, @$dpaths);
283					next;
284					}
285					elsif (ref($dir) && UNIVERSAL::can($dir, 'paths')) {
286					$dpaths = $dir->paths()
287					\|\| return $self->error($dir->error());
288					unshift(@ipaths, @$dpaths);
289					next;
290					}
291					else {
292	2026	1.36ms			push(@opaths, $dir);
293					}
294					}
295	1013	329µs			return $self->error("INCLUDE_PATH exceeds $MAX_DIRS directories")
296					if @ipaths;
297
298	1013	3.83ms			return \@opaths;
299					}
300
301
302					#------------------------------------------------------------------------
303					# DESTROY
304					#
305					# The provider cache is implemented as a doubly linked list which Perl
306					# cannot free by itself due to the circular references between NEXT <=>
307					# PREV items. This cleanup method walks the list deleting all the NEXT/PREV
308					# references, allowing the proper cleanup to occur and memory to be
309					# repooled.
310					#------------------------------------------------------------------------
311
312					# spent 1.73s within Template::Provider::DESTROY which was called 375387 times, avg 5µs/call: # 375387 times (1.73s+0s) by RBM::process_template at line 675 of /root/tor-browser-build/rbm/lib/RBM.pm, avg 5µs/call sub DESTROY {
313	375387	148ms			my $self = shift;
314	375387	116ms			my ($slot, $next);
315
316	375387	280ms			$slot = $self->{ HEAD };
317	375387	277ms			while ($slot) {
318	1013	605µs			$next = $slot->[ NEXT ];
319	1013	478µs			undef $slot->[ PREV ];
320	1013	207µs			undef $slot->[ NEXT ];
321	1013	405µs			$slot = $next;
322					}
323	375387	277ms			undef $self->{ HEAD };
324	375387	1.75s			undef $self->{ TAIL };
325					}
326
- -
330					#========================================================================
331					# -- PRIVATE METHODS --
332					#========================================================================
333
334					#------------------------------------------------------------------------
335					# _init()
336					#
337					# Initialise the cache.
338					#------------------------------------------------------------------------
339
340					# spent 15.7s (15.1+542ms) within Template::Provider::_init which was called 375387 times, avg 42µs/call: # 375387 times (15.1s+542ms) by Template::Base::new at line 65 of Template/Base.pm, avg 42µs/call sub _init {
341	375387	177ms			my ($self, $params) = @_;
342	375387	342ms			my $size = $params->{ CACHE_SIZE };
343	375387	306ms			my $path = $params->{ INCLUDE_PATH } \|\| '.';
344	375387	333ms			my $cdir = $params->{ COMPILE_DIR } \|\| '';
345	375387	162ms			my $dlim = $params->{ DELIMITER };
346	375387	101ms			my $debug;
347
348					# tweak delim to ignore C:/
349	375387	1.34s			unless (defined $dlim) {
350					$dlim = ($^O eq 'MSWin32') ? ':(?!\\/)' : ':';
351					}
352
353					# coerce INCLUDE_PATH to an array ref, if not already so
354	375387	3.66s	375387	542ms	$path = [ split(/$dlim/, $path) ] # spent 542ms making 375387 calls to Template::Provider::CORE:regcomp, avg 1µs/call
355					unless ref $path eq 'ARRAY';
356
357					# don't allow a CACHE_SIZE 1 because it breaks things and the
358					# additional checking isn't worth it
359	375387	203ms			$size = 2
360					if defined $size && ($size == 1 \|\| $size < 0);
361
362	375387	434ms			if (defined ($debug = $params->{ DEBUG })) {
363					$self->{ DEBUG } = $debug & ( Template::Constants::DEBUG_PROVIDER
364					\| Template::Constants::DEBUG_FLAGS );
365					}
366					else {
367	375387	296ms			$self->{ DEBUG } = $DEBUG;
368					}
369
370	375387	202ms			if ($self->{ DEBUG }) {
371					local $" = ', ';
372					$self->debug("creating cache of ",
373					defined $size ? $size : 'unlimited',
374					" slots for [ @$path ]");
375					}
376
377					# create COMPILE_DIR and sub-directories representing each INCLUDE_PATH
378					# element in which to store compiled files
379	375387	179ms			if ($cdir) {
380					require File::Path;
381					foreach my $dir (@$path) {
382					next if ref $dir;
383					my $wdir = $dir;
384					$wdir =~ s[:][]g if $^O eq 'MSWin32';
385					$wdir =~ /(.*)/; # untaint
386					$wdir = "$1"; # quotes work around bug in Strawberry Perl
387					$wdir = File::Spec->catfile($cdir, $wdir);
388					File::Path::mkpath($wdir) unless -d $wdir;
389					}
390					}
391
392	375387	727ms			$self->{ LOOKUP } = { };
393	375387	466ms			$self->{ NOTFOUND } = { }; # Tracks templates not found.
394	375387	417ms			$self->{ SLOTS } = 0;
395	375387	657ms			$self->{ SIZE } = $size;
396	375387	256ms			$self->{ INCLUDE_PATH } = $path;
397	375387	332ms			$self->{ DELIMITER } = $dlim;
398	375387	264ms			$self->{ COMPILE_DIR } = $cdir;
399	375387	386ms			$self->{ COMPILE_EXT } = $params->{ COMPILE_EXT } \|\| '';
400	375387	346ms			$self->{ ABSOLUTE } = $params->{ ABSOLUTE } \|\| 0;
401	375387	390ms			$self->{ RELATIVE } = $params->{ RELATIVE } \|\| 0;
402	375387	534ms			$self->{ TOLERANT } = $params->{ TOLERANT } \|\| 0;
403	375387	459ms			$self->{ DOCUMENT } = $params->{ DOCUMENT } \|\| $DOCUMENT;
404	375387	343ms			$self->{ PARSER } = $params->{ PARSER };
405	375387	282ms			$self->{ DEFAULT } = $params->{ DEFAULT };
406	375387	226ms			$self->{ ENCODING } = $params->{ ENCODING };
407					# $self->{ PREFIX } = $params->{ PREFIX };
408	375387	372ms			$self->{ STAT_TTL } = $params->{ STAT_TTL } \|\| $STAT_TTL;
409	375387	338ms			$self->{ PARAMS } = $params;
410
411					# look for user-provided UNICODE parameter or use default from package var
412					$self->{ UNICODE } = defined $params->{ UNICODE }
413	375387	407ms			? $params->{ UNICODE } : $UNICODE;
414
415	375387	1.80s			return $self;
416					}
417
418
419					#------------------------------------------------------------------------
420					# _fetch($name, $t_name)
421					#
422					# Fetch a file from cache or disk by specification of an absolute or
423					# relative filename. No search of the INCLUDE_PATH is made. If the
424					# file is found and loaded, it is compiled and cached.
425					# Call with:
426					# $name = path to search (possible prefixed by INCLUDE_PATH)
427					# $t_name = template name
428					#------------------------------------------------------------------------
429
430					# spent 12.7s (42.0ms+12.6) within Template::Provider::_fetch which was called 1028 times, avg 12.3ms/call: # 1028 times (42.0ms+12.6s) by Template::Provider::_fetch_path at line 529, avg 12.3ms/call sub _fetch {
431	1028	1.10ms			my ($self, $name, $t_name) = @_;
432	1028	1.35ms			my $stat_ttl = $self->{ STAT_TTL };
433
434	1028	810µs			$self->debug("_fetch($name)") if $self->{ DEBUG };
435
436					# First see if the named template is in the memory cache
437	1028	1.14ms			if ((my $slot = $self->{ LOOKUP }->{ $name })) {
438					# Test if cache is fresh, and reload/compile if not.
439					my ($data, $error) = $self->_refresh($slot);
440
441					return $error
442					? ( $data, $error ) # $data may contain error text
443					: $slot->[ DATA ]; # returned document object
444					}
445
446					# Otherwise, see if we already know the template is not found
447	1028	1.05ms			if (my $last_stat_time = $self->{ NOTFOUND }->{ $name }) {
448					my $expires_in = $last_stat_time + $stat_ttl - time;
449					if ($expires_in > 0) {
450					$self->debug(" file [$name] in negative cache. Expires in $expires_in seconds")
451					if $self->{ DEBUG };
452					return (undef, Template::Constants::STATUS_DECLINED);
453					}
454					else {
455					delete $self->{ NOTFOUND }->{ $name };
456					}
457					}
458
459					# Is there an up-to-date compiled version on disk?
460	1028	3.03ms	1028	12.1ms	if ($self->_compiled_is_current($name)) { # spent 12.1ms making 1028 calls to Template::Provider::_compiled_is_current, avg 12µs/call
461					# require() the compiled template.
462					my $compiled_template = $self->_load_compiled( $self->_compiled_filename($name) );
463
464					# Store and return the compiled template
465					return $self->store( $name, $compiled_template ) if $compiled_template;
466
467					# Problem loading compiled template:
468					# warn and continue to fetch source template
469					warn($self->error(), "\n");
470					}
471
472					# load template from source
473	1028	2.43ms	1028	294ms	my ($template, $error) = $self->_load($name, $t_name); # spent 294ms making 1028 calls to Template::Provider::_load, avg 286µs/call
474
475	1028	568µs			if ($error) {
476					# Template could not be fetched. Add to the negative/notfound cache.
477	15	80µs			$self->{ NOTFOUND }->{ $name } = time;
478	15	59µs			return ( $template, $error );
479					}
480
481					# compile template source
482	1013	5.00ms	2026	12.2s	($template, $error) = $self->_compile($template, $self->_compiled_filename($name) ); # spent 12.2s making 1013 calls to Template::Provider::_compile, avg 12.1ms/call # spent 2.04ms making 1013 calls to Template::Provider::_compiled_filename, avg 2µs/call
483
484	1013	996µs			if ($error) {
485					# return any compile time error
486					return ($template, $error);
487					}
488					else {
489					# Store compiled template and return it
490	1013	13.8ms	1013	89.1ms	return $self->store($name, $template->{data}) ; # spent 89.1ms making 1013 calls to Template::Provider::store, avg 88µs/call
491					}
492					}
493
494
495					#------------------------------------------------------------------------
496					# _fetch_path($name)
497					#
498					# Fetch a file from cache or disk by specification of an absolute cache
499					# name (e.g. 'header') or filename relative to one of the INCLUDE_PATH
500					# directories. If the file isn't already cached and can be found and
501					# loaded, it is compiled and cached under the full filename.
502					#------------------------------------------------------------------------
503
504					# spent 12.7s (28.5ms+12.7) within Template::Provider::_fetch_path which was called 1013 times, avg 12.6ms/call: # 1013 times (28.5ms+12.7s) by Template::Provider::fetch at line 156, avg 12.6ms/call sub _fetch_path {
505	1013	652µs			my ($self, $name) = @_;
506
507	1013	918µs			$self->debug("_fetch_path($name)") if $self->{ DEBUG };
508
509					# the template may have been stored using a non-filename name
510					# so look for the plain name in the cache first
511	1013	1.52ms			if ((my $slot = $self->{ LOOKUP }->{ $name })) {
512					# cached entry exists, so refresh slot and extract data
513					my ($data, $error) = $self->_refresh($slot);
514
515					return $error
516					? ($data, $error)
517					: ($slot->[ DATA ], $error );
518					}
519
520	1013	4.65ms	1013	14.3ms	my $paths = $self->paths # spent 14.3ms making 1013 calls to Template::Provider::paths, avg 14µs/call
521					\|\| return ( $self->error, Template::Constants::STATUS_ERROR );
522
523					# search the INCLUDE_PATH for the file, in cache or on disk
524	1013	1.23ms			foreach my $dir (@$paths) {
525	1028	27.9ms	4112	32.7ms	my $path = File::Spec->catfile($dir, $name); # spent 22.8ms making 1028 calls to File::Spec::Unix::catfile, avg 22µs/call # spent 6.71ms making 1028 calls to File::Spec::Unix::catdir, avg 7µs/call # spent 3.20ms making 2056 calls to File::Spec::Unix::canonpath, avg 2µs/call
526
527	1028	526µs			$self->debug("searching path: $path\n") if $self->{ DEBUG };
528
529	1028	4.32ms	1028	12.7s	my ($data, $error) = $self->_fetch( $path, $name ); # spent 12.7s making 1028 calls to Template::Provider::_fetch, avg 12.3ms/call
530
531					# Return if no error or if a serious error.
532	1028	14.3ms			return ( $data, $error )
533					if !$error \|\| $error == Template::Constants::STATUS_ERROR;
534
535					}
536
537					# not found in INCLUDE_PATH, now try DEFAULT
538					return $self->_fetch_path( $self->{DEFAULT} )
539					if defined $self->{DEFAULT} && $name ne $self->{DEFAULT};
540
541					# We could not handle this template name
542					return (undef, Template::Constants::STATUS_DECLINED);
543					}
544
545					# spent 7.53ms within Template::Provider::_compiled_filename which was called 2041 times, avg 4µs/call: # 1028 times (5.50ms+0s) by Template::Provider::_compiled_is_current at line 918, avg 5µs/call # 1013 times (2.04ms+0s) by Template::Provider::_fetch at line 482, avg 2µs/call sub _compiled_filename {
546	2041	590µs			my ($self, $file) = @_;
547	2041	2.82ms			my ($compext, $compdir) = @$self{ qw( COMPILE_EXT COMPILE_DIR ) };
548	2041	642µs			my ($path, $compiled);
549
550					return undef
551	2041	5.53ms			unless $compext \|\| $compdir;
552
553					$path = $file;
554					$path =~ /^(.+)$/s or die "invalid filename: $path";
555					$path =~ s[:][]g if $^O eq 'MSWin32';
556
557					$compiled = "$path$compext";
558					$compiled = File::Spec->catfile($compdir, $compiled) if length $compdir;
559
560					return $compiled;
561					}
562
563					sub _load_compiled {
564					my ($self, $file) = @_;
565					my $compiled;
566
567					# load compiled template via require(); we zap any
568					# %INC entry to ensure it is reloaded (we don't
569					# want 1 returned by require() to say it's in memory)
570					delete $INC{ $file };
571					eval { $compiled = require $file; };
572					return $@
573					? $self->error("compiled template $compiled: $@")
574					: $compiled;
575					}
576
577					#------------------------------------------------------------------------
578					# _load($name, $alias)
579					#
580					# Load template text from a string ($name = scalar ref), GLOB or file
581					# handle ($name = ref), or from an absolute filename ($name = scalar).
582					# Returns a hash array containing the following items:
583					# name filename or $alias, if provided, or 'input text', etc.
584					# text template text
585					# time modification time of file, or current time for handles/strings
586					# load time file was loaded (now!)
587					#
588					# On error, returns ($error, STATUS_ERROR), or (undef, STATUS_DECLINED)
589					# if TOLERANT is set.
590					#------------------------------------------------------------------------
591
592					# spent 4.31s (4.05+263ms) within Template::Provider::_load which was called 376415 times, avg 11µs/call: # 375387 times (4.02s+0s) by Template::Provider::fetch at line 129, avg 11µs/call # 1028 times (31.3ms+263ms) by Template::Provider::_fetch at line 473, avg 286µs/call sub _load {
593	376415	218ms			my ($self, $name, $alias) = @_;
594	376415	113ms			my ($data, $error);
595	376415	354ms			my $tolerant = $self->{ TOLERANT };
596	376415	324ms			my $now = time;
597
598	376415	300ms			$alias = $name unless defined $alias or ref $name;
599
600					$self->debug("_load($name, ", defined $alias ? $alias : '<no alias>',
601	376415	203ms			')') if $self->{ DEBUG };
602
603					# SCALAR ref is the template text
604	376415	3.44s			if (ref $name eq 'SCALAR') {
605					# $name can be a SCALAR reference to the input text...
606					return {
607					name => defined $alias ? $alias : 'input text',
608					path => defined $alias ? $alias : 'input text',
609					text => $$name,
610					time => $now,
611					load => 0,
612					};
613					}
614
615					# Otherwise, assume GLOB as a file handle
616	1028	608µs			if (ref $name) {
617					local $/;
618					my $text = <$name>;
619					$text = $self->_decode_unicode($text) if $self->{ UNICODE };
620					return {
621					name => defined $alias ? $alias : 'input file handle',
622					path => defined $alias ? $alias : 'input file handle',
623					text => $text,
624					time => $now,
625					load => 0,
626					};
627					}
628
629					# Otherwise, it's the name of the template
630	1028	3.19ms	1028	38.5ms	if ( $self->_template_modified( $name ) ) { # does template exist? # spent 38.5ms making 1028 calls to Template::Provider::_template_modified, avg 37µs/call
631	1013	3.73ms	1013	117ms	my ($text, $error, $mtime ) = $self->_template_content( $name ); # spent 117ms making 1013 calls to Template::Provider::_template_content, avg 116µs/call
632	1013	651µs			unless ( $error ) {
633	1013	5.15ms	1013	107ms	$text = $self->_decode_unicode($text) if $self->{ UNICODE }; # spent 107ms making 1013 calls to Template::Provider::_decode_unicode, avg 106µs/call
634					return {
635	1013	6.25ms			name => $alias,
636					path => $name,
637					text => $text,
638					time => $mtime,
639					load => $now,
640					};
641					}
642
643					return ( $error, Template::Constants::STATUS_ERROR )
644					unless $tolerant;
645					}
646
647					# Unable to process template, pass onto the next Provider.
648	15	146µs			return (undef, Template::Constants::STATUS_DECLINED);
649					}
650
651
652					#------------------------------------------------------------------------
653					# _refresh(\@slot)
654					#
655					# Private method called to mark a cache slot as most recently used.
656					# A reference to the slot array should be passed by parameter. The
657					# slot is relocated to the head of the linked list. If the file from
658					# which the data was loaded has been updated since it was compiled, then
659					# it is re-loaded from disk and re-compiled.
660					#------------------------------------------------------------------------
661
662					sub _refresh {
663					my ($self, $slot) = @_;
664					my $stat_ttl = $self->{ STAT_TTL };
665					my ($head, $file, $data, $error);
666
667					$self->debug("_refresh([ ",
668					join(', ', map { defined $_ ? $_ : '<undef>' } @$slot),
669					'])') if $self->{ DEBUG };
670
671					# if it's more than $STAT_TTL seconds since we last performed a
672					# stat() on the file then we need to do it again and see if the file
673					# time has changed
674					my $now = time;
675					my $expires_in_sec = $slot->[ STAT ] + $stat_ttl - $now;
676
677					if ( $expires_in_sec <= 0 ) { # Time to check!
678					$slot->[ STAT ] = $now;
679
680					# Grab mtime of template.
681					# Seems like this should be abstracted to compare to
682					# just ask for a newer compiled template (if it's newer)
683					# and let that check for a newer template source.
684					my $template_mtime = $self->_template_modified( $slot->[ NAME ] );
685					if ( ! defined $template_mtime \|\| ( $template_mtime != $slot->[ LOAD ] )) {
686					$self->debug("refreshing cache file ", $slot->[ NAME ])
687					if $self->{ DEBUG };
688
689					($data, $error) = $self->_load($slot->[ NAME ], $slot->[ DATA ]->{ name });
690					($data, $error) = $self->_compile($data)
691					unless $error;
692
693					if ($error) {
694					# if the template failed to load/compile then we wipe out the
695					# STAT entry. This forces the provider to try and reload it
696					# each time instead of using the previously cached version
697					# until $STAT_TTL is next up
698					$slot->[ STAT ] = 0;
699					}
700					else {
701					$slot->[ DATA ] = $data->{ data };
702					$slot->[ LOAD ] = $data->{ time };
703					}
704					}
705
706					} elsif ( $self->{ DEBUG } ) {
707					$self->debug( sprintf('STAT_TTL not met for file [%s]. Expires in %d seconds',
708					$slot->[ NAME ], $expires_in_sec ) );
709					}
710
711					# Move this slot to the head of the list
712					unless( $self->{ HEAD } == $slot ) {
713					# remove existing slot from usage chain...
714					if ($slot->[ PREV ]) {
715					$slot->[ PREV ]->[ NEXT ] = $slot->[ NEXT ];
716					}
717					else {
718					$self->{ HEAD } = $slot->[ NEXT ];
719					}
720					if ($slot->[ NEXT ]) {
721					$slot->[ NEXT ]->[ PREV ] = $slot->[ PREV ];
722					}
723					else {
724					$self->{ TAIL } = $slot->[ PREV ];
725					}
726
727					# ..and add to start of list
728					$head = $self->{ HEAD };
729					$head->[ PREV ] = $slot if $head;
730					$slot->[ PREV ] = undef;
731					$slot->[ NEXT ] = $head;
732					$self->{ HEAD } = $slot;
733					}
734
735					return ($data, $error);
736					}
737
- -
740					#------------------------------------------------------------------------
741					# _store($name, $data)
742					#
743					# Private method called to add a data item to the cache. If the cache
744					# size limit has been reached then the oldest entry at the tail of the
745					# list is removed and its slot relocated to the head of the list and
746					# reused for the new data item. If the cache is under the size limit,
747					# or if no size limit is defined, then the item is added to the head
748					# of the list.
749					# Returns compiled template
750					#------------------------------------------------------------------------
751
752					# spent 77.2ms (28.1+49.2) within Template::Provider::_store which was called 1013 times, avg 76µs/call: # 1013 times (28.1ms+49.2ms) by Template::Provider::store at line 176, avg 76µs/call sub _store {
753	1013	932µs			my ($self, $name, $data, $compfile) = @_;
754	1013	2.00ms			my $size = $self->{ SIZE };
755	1013	605µs			my ($slot, $head);
756
757					# Return if memory cache disabled. (overriding code should also check)
758					# $$$ What's the expected behaviour of store()? Can't tell from the
759					# docs if you can call store() when SIZE = 0.
760	1013	590µs			return $data->{data} if defined $size and !$size;
761
762					# extract the compiled template from the data hash
763	1013	979µs			$data = $data->{ data };
764	1013	1.17ms			$self->debug("_store($name, $data)") if $self->{ DEBUG };
765
766					# check the modification time -- extra stat here
767	1013	4.19ms	1013	49.2ms	my $load = $self->_modified($name); # spent 49.2ms making 1013 calls to Template::Provider::_modified, avg 49µs/call
768
769	1013	1.07ms			if (defined $size && $self->{ SLOTS } >= $size) {
770					# cache has reached size limit, so reuse oldest entry
771					$self->debug("reusing oldest cache entry (size limit reached: $size)\nslots: $self->{ SLOTS }") if $self->{ DEBUG };
772
773					# remove entry from tail of list
774					$slot = $self->{ TAIL };
775					$slot->[ PREV ]->[ NEXT ] = undef;
776					$self->{ TAIL } = $slot->[ PREV ];
777
778					# remove name lookup for old node
779					delete $self->{ LOOKUP }->{ $slot->[ NAME ] };
780
781					# add modified node to head of list
782					$head = $self->{ HEAD };
783					$head->[ PREV ] = $slot if $head;
784					@$slot = ( undef, $name, $data, $load, $head, time );
785					$self->{ HEAD } = $slot;
786
787					# add name lookup for new node
788					$self->{ LOOKUP }->{ $name } = $slot;
789					}
790					else {
791					# cache is under size limit, or none is defined
792
793	1013	1.15ms			$self->debug("adding new cache entry") if $self->{ DEBUG };
794
795					# add new node to head of list
796	1013	1.13ms			$head = $self->{ HEAD };
797	1013	2.33ms			$slot = [ undef, $name, $data, $load, $head, time ];
798	1013	413µs			$head->[ PREV ] = $slot if $head;
799	1013	1.23ms			$self->{ HEAD } = $slot;
800	1013	1.97ms			$self->{ TAIL } = $slot unless $self->{ TAIL };
801
802					# add lookup from name to slot and increment nslots
803	1013	2.72ms			$self->{ LOOKUP }->{ $name } = $slot;
804	1013	948µs			$self->{ SLOTS }++;
805					}
806
807	1013	4.19ms			return $data;
808					}
809
810
811					#------------------------------------------------------------------------
812					# _compile($data)
813					#
814					# Private method called to parse the template text and compile it into
815					# a runtime form. Creates and delegates a Template::Parser object to
816					# handle the compilation, or uses a reference passed in PARSER. On
817					# success, the compiled template is stored in the 'data' item of the
818					# $data hash and returned. On error, ($error, STATUS_ERROR) is returned,
819					# or (undef, STATUS_DECLINED) if the TOLERANT flag is set.
820					# The optional $compiled parameter may be passed to specify
821					# the name of a compiled template file to which the generated Perl
822					# code should be written. Errors are (for now...) silently
823					# ignored, assuming that failures to open a file for writing are
824					# intentional (e.g directory write permission).
825					#------------------------------------------------------------------------
826
827					# spent 391s (12.3+379) within Template::Provider::_compile which was called 376400 times, avg 1.04ms/call: # 375387 times (12.3s+367s) by Template::Provider::fetch at line 130, avg 1.01ms/call # 1013 times (45.5ms+12.2s) by Template::Provider::_fetch at line 482, avg 12.1ms/call sub _compile {
828	376400	206ms			my ($self, $data, $compfile) = @_;
829	376400	481ms			my $text = $data->{ text };
830	376400	105ms			my ($parsedoc, $error);
831
832					$self->debug("_compile($data, ",
833					defined $compfile ? $compfile : '<no compfile>', ')')
834	376400	167ms			if $self->{ DEBUG };
835
836					my $parser = $self->{ PARSER }
837					\|\|= Template::Config->parser($self->{ PARAMS })
838	376400	1.20s	375387	57.2s	\|\| return (Template::Config->error(), Template::Constants::STATUS_ERROR); # spent 57.2s making 375387 calls to Template::Config::parser, avg 152µs/call
839
840					# discard the template text - we don't need it any more
841	376400	292ms			delete $data->{ text };
842
843					# call parser to compile template into Perl code
844	376400	1.14s	376400	239s	if ($parsedoc = $parser->parse($text, $data)) { # spent 239s making 376400 calls to Template::Parser::parse, avg 634µs/call
845
846					$parsedoc->{ METADATA } = {
847					'name' => $data->{ name },
848					'modtime' => $data->{ time },
849	376400	1.29s			%{ $parsedoc->{ METADATA } },
850					};
851
852					# write the Perl code to the file $compfile, if defined
853	376400	168ms			if ($compfile) {
854					my $basedir = &File::Basename::dirname($compfile);
855					$basedir =~ /(.*)/;
856					$basedir = $1;
857
858					unless (-d $basedir) {
859					eval { File::Path::mkpath($basedir) };
860					$error = "failed to create compiled templates directory: $basedir ($@)"
861					if ($@);
862					}
863
864					unless ($error) {
865					my $docclass = $self->{ DOCUMENT };
866					$error = 'cache failed to write '
867					. &File::Basename::basename($compfile)
868					. ': ' . $docclass->error()
869					unless $docclass->write_perl_file($compfile, $parsedoc);
870					}
871
872					# set atime and mtime of newly compiled file, don't bother
873					# if time is undef
874					if (!defined($error) && defined $data->{ time }) {
875					my ($cfile) = $compfile =~ /^(.+)$/s or do {
876					return("invalid filename: $compfile",
877					Template::Constants::STATUS_ERROR);
878					};
879
880					my ($ctime) = $data->{ time } =~ /^(\d+)$/;
881					unless ($ctime \|\| $ctime eq 0) {
882					return("invalid time: $ctime",
883					Template::Constants::STATUS_ERROR);
884					}
885					utime($ctime, $ctime, $cfile);
886
887					$self->debug(" cached compiled template to file [$compfile]")
888					if $self->{ DEBUG };
889					}
890					}
891
892	376400	171ms			unless ($error) {
893					return $data ## RETURN ##
894	376400	4.37s	376400	83.1s	if $data->{ data } = $DOCUMENT->new($parsedoc); # spent 83.1s making 376400 calls to Template::Document::new, avg 221µs/call
895					$error = $Template::Document::ERROR;
896					}
897					}
898					else {
899					$error = Template::Exception->new( 'parse', "$data->{ name } " .
900					$parser->error() );
901					}
902
903					# return STATUS_ERROR, or STATUS_DECLINED if we're being tolerant
904					return $self->{ TOLERANT }
905					? (undef, Template::Constants::STATUS_DECLINED)
906					: ($error, Template::Constants::STATUS_ERROR)
907					}
908
909					#------------------------------------------------------------------------
910					# _compiled_is_current( $template_name )
911					#
912					# Returns true if $template_name and its compiled name
913					# exist and they have the same mtime.
914					#------------------------------------------------------------------------
915
916					# spent 12.1ms (6.61+5.50) within Template::Provider::_compiled_is_current which was called 1028 times, avg 12µs/call: # 1028 times (6.61ms+5.50ms) by Template::Provider::_fetch at line 460, avg 12µs/call sub _compiled_is_current {
917	1028	926µs			my ( $self, $template_name ) = @_;
918	1028	6.07ms	1028	5.50ms	my $compiled_name = $self->_compiled_filename($template_name) \|\| return; # spent 5.50ms making 1028 calls to Template::Provider::_compiled_filename, avg 5µs/call
919					my $compiled_mtime = (stat($compiled_name))[9] \|\| return;
920					my $template_mtime = $self->_template_modified( $template_name ) \|\| return;
921
922					# This was >= in the 2.15, but meant that downgrading
923					# a source template would not get picked up.
924					return $compiled_mtime == $template_mtime;
925					}
926
927
928					#------------------------------------------------------------------------
929					# _template_modified($path)
930					#
931					# Returns the last modified time of the $path.
932					# Returns undef if the path does not exist.
933					# Override if templates are not on disk, for example
934					#------------------------------------------------------------------------
935
936					# spent 77.5ms (16.7+60.8) within Template::Provider::_template_modified which was called 2041 times, avg 38µs/call: # 1028 times (7.08ms+31.4ms) by Template::Provider::_load at line 630, avg 37µs/call # 1013 times (9.59ms+29.5ms) by Template::Provider::_modified at line 995, avg 39µs/call sub _template_modified {
937	2041	1.84ms			my $self = shift;
938	2041	1.77ms			my $template = shift \|\| return;
939	2041	77.6ms	2041	60.8ms	return (stat( $template ))[9]; # spent 60.8ms making 2041 calls to Template::Provider::CORE:stat, avg 30µs/call
940					}
941
942					#------------------------------------------------------------------------
943					# _template_content($path)
944					#
945					# Fetches content pointed to by $path.
946					# Returns the content in scalar context.
947					# Returns ($data, $error, $mtime) in list context where
948					# $data - content
949					# $error - error string if there was an error, otherwise undef
950					# $mtime - last modified time from calling stat() on the path
951					#------------------------------------------------------------------------
952
953					# spent 117ms (42.3+74.9) within Template::Provider::_template_content which was called 1013 times, avg 116µs/call: # 1013 times (42.3ms+74.9ms) by Template::Provider::_load at line 631, avg 116µs/call sub _template_content {
954	1013	532µs			my ($self, $path) = @_;
955
956	1013	424µs			return (undef, "No path specified to fetch content from ")
957					unless $path;
958
959	1013	331µs			my $data;
960					my $mod_date;
961					my $error;
962
963	1013	2.16ms			local *FH;
964	1013	52.9ms	2026	44.1ms	if(-d $path) { # spent 40.6ms making 1013 calls to Template::Provider::CORE:open, avg 40µs/call # spent 3.48ms making 1013 calls to Template::Provider::CORE:ftdir, avg 3µs/call
965					$error = "$path: not a file";
966					}
967					elsif (open(FH, "< $path")) {
968	1013	4.19ms			local $/;
969	1013	5.40ms	1013	2.61ms	binmode(FH); # spent 2.61ms making 1013 calls to Template::Provider::CORE:binmode, avg 3µs/call
970	1013	21.1ms	1013	17.6ms	$data = <FH>; # spent 17.6ms making 1013 calls to Template::Provider::CORE:readline, avg 17µs/call
971	1013	5.51ms	1013	2.32ms	$mod_date = (stat($path))[9]; # spent 2.32ms making 1013 calls to Template::Provider::CORE:stat, avg 2µs/call
972	1013	19.5ms	1013	8.30ms	close(FH); # spent 8.30ms making 1013 calls to Template::Provider::CORE:close, avg 8µs/call
973					}
974					else {
975					$error = "$path: $!";
976					}
977
978					return wantarray
979	1013	13.4ms			? ( $data, $error, $mod_date )
980					: $data;
981					}
982
983
984					#------------------------------------------------------------------------
985					# _modified($name)
986					# _modified($name, $time)
987					#
988					# When called with a single argument, it returns the modification time
989					# of the named template. When called with a second argument it returns
990					# true if $name has been modified since $time.
991					#------------------------------------------------------------------------
992
993					# spent 49.2ms (10.1+39.1) within Template::Provider::_modified which was called 1013 times, avg 49µs/call: # 1013 times (10.1ms+39.1ms) by Template::Provider::_store at line 767, avg 49µs/call sub _modified {
994	1013	861µs			my ($self, $name, $time) = @_;
995	1013	4.33ms	1013	39.1ms	my $load = $self->_template_modified($name) # spent 39.1ms making 1013 calls to Template::Provider::_template_modified, avg 39µs/call
996					\|\| return $time ? 1 : 0;
997
998	1013	4.29ms			return $time
999					? $load > $time
1000					: $load;
1001					}
1002
1003					#------------------------------------------------------------------------
1004					# _dump()
1005					#
1006					# Debug method which returns a string representing the internal object
1007					# state.
1008					#------------------------------------------------------------------------
1009
1010					sub _dump {
1011					my $self = shift;
1012					my $size = $self->{ SIZE };
1013					my $parser = $self->{ PARSER };
1014					$parser = $parser ? $parser->_dump() : '<no parser>';
1015					$parser =~ s/\n/\n /gm;
1016					$size = 'unlimited' unless defined $size;
1017
1018					my $output = "[Template::Provider] {\n";
1019					my $format = " %-16s => %s\n";
1020					my $key;
1021
1022					$output .= sprintf($format, 'INCLUDE_PATH',
1023					'[ ' . join(', ', @{ $self->{ INCLUDE_PATH } }) . ' ]');
1024					$output .= sprintf($format, 'CACHE_SIZE', $size);
1025
1026					foreach $key (qw( ABSOLUTE RELATIVE TOLERANT DELIMITER
1027					COMPILE_EXT COMPILE_DIR )) {
1028					$output .= sprintf($format, $key, $self->{ $key });
1029					}
1030					$output .= sprintf($format, 'PARSER', $parser);
1031
1032
1033					local $" = ', ';
1034					my $lookup = $self->{ LOOKUP };
1035					$lookup = join('', map {
1036					sprintf(" $format", $_, defined $lookup->{ $_ }
1037					? ('[ ' . join(', ', map { defined $_ ? $_ : '<undef>' }
1038					@{ $lookup->{ $_ } }) . ' ]') : '<undef>');
1039					} sort keys %$lookup);
1040					$lookup = "{\n$lookup }";
1041
1042					$output .= sprintf($format, LOOKUP => $lookup);
1043
1044					$output .= '}';
1045					return $output;
1046					}
1047
1048
1049					#------------------------------------------------------------------------
1050					# _dump_cache()
1051					#
1052					# Debug method which prints the current state of the cache to STDERR.
1053					#------------------------------------------------------------------------
1054
1055					sub _dump_cache {
1056					my $self = shift;
1057					my ($node, $lut, $count);
1058
1059					$count = 0;
1060					if ($node = $self->{ HEAD }) {
1061					while ($node) {
1062					$lut->{ $node } = $count++;
1063					$node = $node->[ NEXT ];
1064					}
1065					$node = $self->{ HEAD };
1066					print STDERR "CACHE STATE:\n";
1067					print STDERR " HEAD: ", $self->{ HEAD }->[ NAME ], "\n";
1068					print STDERR " TAIL: ", $self->{ TAIL }->[ NAME ], "\n";
1069					while ($node) {
1070					my ($prev, $name, $data, $load, $next) = @$node;
1071					# $name = '...' . substr($name, -10) if length $name > 10;
1072					$prev = $prev ? "#$lut->{ $prev }<-": '<undef>';
1073					$next = $next ? "->#$lut->{ $next }": '<undef>';
1074					print STDERR " #$lut->{ $node } : [ $prev, $name, $data, $load, $next ]\n";
1075					$node = $node->[ NEXT ];
1076					}
1077					}
1078					}
1079
1080					#------------------------------------------------------------------------
1081					# _decode_unicode
1082					#
1083					# Decodes encoded unicode text that starts with a BOM and
1084					# turns it into perl's internal representation
1085					#------------------------------------------------------------------------
1086
1087					# spent 107ms (25.8+81.7) within Template::Provider::_decode_unicode which was called 1013 times, avg 106µs/call: # 1013 times (25.8ms+81.7ms) by Template::Provider::_load at line 633, avg 106µs/call sub _decode_unicode {
1088	1013	433µs			my $self = shift;
1089	1013	482µs			my $string = shift;
1090	1013	148µs			return undef unless defined $string;
1091
1092	2	156µs	2	20µs	# spent 16µs (13+3) within Template::Provider::BEGIN@1092 which was called: # once (13µs+3µs) by Template::BEGIN@29 at line 1092 use bytes; # spent 16µs making 1 call to Template::Provider::BEGIN@1092 # spent 3µs making 1 call to bytes::import
1093	1013	1.42ms			require Encode;
1094
1095	1013	6.41ms	1013	2.33ms	return $string if Encode::is_utf8( $string ); # spent 2.33ms making 1013 calls to Encode::is_utf8, avg 2µs/call
1096
1097					# try all the BOMs in order looking for one (order is important
1098					# 32bit BOMs look like 16bit BOMs)
1099
1100	1013	558µs			my $count = 0;
1101
1102	1013	1.24ms			while ($count < @{ $boms }) {
1103	5065	3.53ms			my $enc = $boms->[$count++];
1104	5065	3.33ms			my $bom = $boms->[$count++];
1105
1106					# does the string start with the bom?
1107	5065	4.43ms			if ($bom eq substr($string, 0, length($bom))) {
1108					# decode it and hand it back
1109					return Encode::decode($enc, substr($string, length($bom)), 1);
1110					}
1111					}
1112
1113					return $self->{ ENCODING }
1114	1013	6.14ms	1013	79.3ms	? Encode::decode( $self->{ ENCODING }, $string ) # spent 79.3ms making 1013 calls to Encode::decode, avg 78µs/call
1115					: $string;
1116					}
1117
1118
1119	1	8µs			1;
1120
1121					__END__

					# spent 2.61ms within Template::Provider::CORE:binmode which was called 1013 times, avg 3µs/call: # 1013 times (2.61ms+0s) by Template::Provider::_template_content at line 969, avg 3µs/call sub Template::Provider::CORE:binmode; # opcode
					# spent 8.30ms within Template::Provider::CORE:close which was called 1013 times, avg 8µs/call: # 1013 times (8.30ms+0s) by Template::Provider::_template_content at line 972, avg 8µs/call sub Template::Provider::CORE:close; # opcode
					# spent 3.48ms within Template::Provider::CORE:ftdir which was called 1013 times, avg 3µs/call: # 1013 times (3.48ms+0s) by Template::Provider::_template_content at line 964, avg 3µs/call sub Template::Provider::CORE:ftdir; # opcode
					# spent 1.29ms within Template::Provider::CORE:match which was called 1013 times, avg 1µs/call: # 1013 times (1.29ms+0s) by Template::Provider::fetch at line 127, avg 1µs/call sub Template::Provider::CORE:match; # opcode
					# spent 40.6ms within Template::Provider::CORE:open which was called 1013 times, avg 40µs/call: # 1013 times (40.6ms+0s) by Template::Provider::_template_content at line 964, avg 40µs/call sub Template::Provider::CORE:open; # opcode
					# spent 2µs within Template::Provider::CORE:qr which was called: # once (2µs+0s) by Template::BEGIN@29 at line 82 sub Template::Provider::CORE:qr; # opcode
					# spent 17.6ms within Template::Provider::CORE:readline which was called 1013 times, avg 17µs/call: # 1013 times (17.6ms+0s) by Template::Provider::_template_content at line 970, avg 17µs/call sub Template::Provider::CORE:readline; # opcode
					# spent 542ms within Template::Provider::CORE:regcomp which was called 376400 times, avg 1µs/call: # 375387 times (542ms+0s) by Template::Provider::_init at line 354, avg 1µs/call # 1013 times (297µs+0s) by Template::Provider::fetch at line 127, avg 293ns/call sub Template::Provider::CORE:regcomp; # opcode
					# spent 63.2ms within Template::Provider::CORE:stat which was called 3054 times, avg 21µs/call: # 2041 times (60.8ms+0s) by Template::Provider::_template_modified at line 939, avg 30µs/call # 1013 times (2.32ms+0s) by Template::Provider::_template_content at line 971, avg 2µs/call sub Template::Provider::CORE:stat; # opcode
					# spent 2µs within Template::Provider::__ANON__ which was called 3 times, avg 667ns/call: # once (1µs+0s) by Template::Provider::BEGIN@46 at line 46 # once (500ns+0s) by Template::Provider::BEGIN@48 at line 48 # once (500ns+0s) by Template::Provider::BEGIN@44 at line 44 sub Template::Provider::__ANON__; # xsub