733 lines
18 KiB
PHP
733 lines
18 KiB
PHP
|
<?php
|
||
|
/**
|
||
|
* Smarty Internal Plugin Template
|
||
|
* This file contains the Smarty template engine
|
||
|
*
|
||
|
|
||
|
|
||
|
* @author Uwe Tews
|
||
|
*/
|
||
|
|
||
|
namespace Smarty;
|
||
|
|
||
|
use Smarty\Resource\BasePlugin;
|
||
|
use Smarty\Runtime\InheritanceRuntime;
|
||
|
use Smarty\Template\Source;
|
||
|
use Smarty\Template\Cached;
|
||
|
use Smarty\Template\Compiled;
|
||
|
use Smarty\Template\Config;
|
||
|
|
||
|
/**
|
||
|
* Main class with template data structures and methods
|
||
|
*/
|
||
|
#[\AllowDynamicProperties]
|
||
|
class Template extends TemplateBase {
|
||
|
|
||
|
/**
|
||
|
* caching mode to create nocache code but no cache file
|
||
|
*/
|
||
|
public const CACHING_NOCACHE_CODE = 9999;
|
||
|
|
||
|
/**
|
||
|
* @var Compiled
|
||
|
*/
|
||
|
private $compiled = null;
|
||
|
|
||
|
/**
|
||
|
* @var Cached
|
||
|
*/
|
||
|
private $cached = null;
|
||
|
|
||
|
/**
|
||
|
* @var \Smarty\Compiler\Template
|
||
|
*/
|
||
|
private $compiler = null;
|
||
|
|
||
|
/**
|
||
|
* Source instance
|
||
|
*
|
||
|
* @var Source|Config
|
||
|
*/
|
||
|
private $source = null;
|
||
|
|
||
|
/**
|
||
|
* Template resource
|
||
|
*
|
||
|
* @var string
|
||
|
*/
|
||
|
public $template_resource = null;
|
||
|
|
||
|
/**
|
||
|
* Template ID
|
||
|
*
|
||
|
* @var null|string
|
||
|
*/
|
||
|
public $templateId = null;
|
||
|
|
||
|
/**
|
||
|
* Callbacks called before rendering template
|
||
|
*
|
||
|
* @var callback[]
|
||
|
*/
|
||
|
public $startRenderCallbacks = [];
|
||
|
|
||
|
/**
|
||
|
* Callbacks called after rendering template
|
||
|
*
|
||
|
* @var callback[]
|
||
|
*/
|
||
|
public $endRenderCallbacks = [];
|
||
|
|
||
|
/**
|
||
|
* Template left-delimiter. If null, defaults to $this->getSmarty()-getLeftDelimiter().
|
||
|
*
|
||
|
* @var string
|
||
|
*/
|
||
|
private $left_delimiter = null;
|
||
|
|
||
|
/**
|
||
|
* Template right-delimiter. If null, defaults to $this->getSmarty()-getRightDelimiter().
|
||
|
*
|
||
|
* @var string
|
||
|
*/
|
||
|
private $right_delimiter = null;
|
||
|
|
||
|
/**
|
||
|
* @var InheritanceRuntime|null
|
||
|
*/
|
||
|
private $inheritance;
|
||
|
|
||
|
/**
|
||
|
* Create template data object
|
||
|
* Some of the global Smarty settings copied to template scope
|
||
|
* It load the required template resources and caching plugins
|
||
|
*
|
||
|
* @param string $template_resource template resource string
|
||
|
* @param Smarty $smarty Smarty instance
|
||
|
* @param \Smarty\Data|null $_parent back pointer to parent object with variables or null
|
||
|
* @param mixed $_cache_id cache id or null
|
||
|
* @param mixed $_compile_id compile id or null
|
||
|
* @param bool|int|null $_caching use caching?
|
||
|
* @param bool $_isConfig
|
||
|
*
|
||
|
* @throws \Smarty\Exception
|
||
|
*/
|
||
|
public function __construct(
|
||
|
$template_resource,
|
||
|
Smarty $smarty,
|
||
|
?\Smarty\Data $_parent = null,
|
||
|
$_cache_id = null,
|
||
|
$_compile_id = null,
|
||
|
$_caching = null,
|
||
|
$_isConfig = false
|
||
|
) {
|
||
|
$this->smarty = $smarty;
|
||
|
// Smarty parameter
|
||
|
$this->cache_id = $_cache_id === null ? $this->smarty->cache_id : $_cache_id;
|
||
|
$this->compile_id = $_compile_id === null ? $this->smarty->compile_id : $_compile_id;
|
||
|
$this->caching = (int)($_caching === null ? $this->smarty->caching : $_caching);
|
||
|
$this->cache_lifetime = $this->smarty->cache_lifetime;
|
||
|
$this->compile_check = (int)$smarty->compile_check;
|
||
|
$this->parent = $_parent;
|
||
|
// Template resource
|
||
|
$this->template_resource = $template_resource;
|
||
|
|
||
|
$this->source = $_isConfig ? Config::load($this) : Source::load($this);
|
||
|
$this->compiled = Compiled::load($this);
|
||
|
|
||
|
if ($smarty->security_policy) {
|
||
|
$smarty->security_policy->registerCallBacks($this);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* render template
|
||
|
*
|
||
|
* @param bool $no_output_filter if true do not run output filter
|
||
|
* @param null|bool $display true: display, false: fetch null: sub-template
|
||
|
*
|
||
|
* @return string
|
||
|
* @throws \Exception
|
||
|
* @throws \Smarty\Exception
|
||
|
*/
|
||
|
private function render($no_output_filter = true, $display = null) {
|
||
|
if ($this->smarty->debugging) {
|
||
|
$this->smarty->getDebug()->start_template($this, $display);
|
||
|
}
|
||
|
// checks if template exists
|
||
|
if ($this->compile_check && !$this->getSource()->exists) {
|
||
|
throw new Exception(
|
||
|
"Unable to load '{$this->getSource()->type}:{$this->getSource()->name}'" .
|
||
|
($this->_isSubTpl() ? " in '{$this->parent->template_resource}'" : '')
|
||
|
);
|
||
|
}
|
||
|
|
||
|
// disable caching for evaluated code
|
||
|
if ($this->getSource()->handler->recompiled) {
|
||
|
$this->caching = \Smarty\Smarty::CACHING_OFF;
|
||
|
}
|
||
|
|
||
|
foreach ($this->startRenderCallbacks as $callback) {
|
||
|
call_user_func($callback, $this);
|
||
|
}
|
||
|
|
||
|
try {
|
||
|
|
||
|
// read from cache or render
|
||
|
if ($this->caching === \Smarty\Smarty::CACHING_LIFETIME_CURRENT || $this->caching === \Smarty\Smarty::CACHING_LIFETIME_SAVED) {
|
||
|
$this->getCached()->render($this, $no_output_filter);
|
||
|
} else {
|
||
|
$this->getCompiled()->render($this);
|
||
|
}
|
||
|
|
||
|
} finally {
|
||
|
foreach ($this->endRenderCallbacks as $callback) {
|
||
|
call_user_func($callback, $this);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// display or fetch
|
||
|
if ($display) {
|
||
|
if ($this->caching && $this->smarty->cache_modified_check) {
|
||
|
$this->smarty->cacheModifiedCheck(
|
||
|
$this->getCached(),
|
||
|
$this,
|
||
|
isset($content) ? $content : ob_get_clean()
|
||
|
);
|
||
|
} else {
|
||
|
if ((!$this->caching || $this->getCached()->getNocacheCode() || $this->getSource()->handler->recompiled)
|
||
|
&& !$no_output_filter
|
||
|
) {
|
||
|
echo $this->smarty->runOutputFilters(ob_get_clean(), $this);
|
||
|
} else {
|
||
|
echo ob_get_clean();
|
||
|
}
|
||
|
}
|
||
|
if ($this->smarty->debugging) {
|
||
|
$this->smarty->getDebug()->end_template($this);
|
||
|
// debug output
|
||
|
$this->smarty->getDebug()->display_debug($this, true);
|
||
|
}
|
||
|
return '';
|
||
|
} else {
|
||
|
if ($this->smarty->debugging) {
|
||
|
$this->smarty->getDebug()->end_template($this);
|
||
|
if ($this->smarty->debugging === 2 && $display === false) {
|
||
|
$this->smarty->getDebug()->display_debug($this, true);
|
||
|
}
|
||
|
}
|
||
|
if (
|
||
|
!$no_output_filter
|
||
|
&& (!$this->caching || $this->getCached()->getNocacheCode() || $this->getSource()->handler->recompiled)
|
||
|
) {
|
||
|
|
||
|
return $this->smarty->runOutputFilters(ob_get_clean(), $this);
|
||
|
}
|
||
|
// return cache content
|
||
|
return null;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Runtime function to render sub-template
|
||
|
*
|
||
|
* @param string $template_name template name
|
||
|
* @param mixed $cache_id cache id
|
||
|
* @param mixed $compile_id compile id
|
||
|
* @param integer $caching cache mode
|
||
|
* @param integer $cache_lifetime lifetime of cache data
|
||
|
* @param array $extra_vars passed parameter template variables
|
||
|
* @param int|null $scope
|
||
|
*
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function renderSubTemplate(
|
||
|
$template_name,
|
||
|
$cache_id,
|
||
|
$compile_id,
|
||
|
$caching,
|
||
|
$cache_lifetime,
|
||
|
array $extra_vars = [],
|
||
|
?int $scope = null,
|
||
|
?string $currentDir = null
|
||
|
) {
|
||
|
|
||
|
$name = $this->parseResourceName($template_name);
|
||
|
if ($currentDir && preg_match('/^\.{1,2}\//', $name)) {
|
||
|
// relative template resource name, append it to current template name
|
||
|
$template_name = $currentDir . DIRECTORY_SEPARATOR . $name;
|
||
|
}
|
||
|
|
||
|
$tpl = $this->smarty->doCreateTemplate($template_name, $cache_id, $compile_id, $this, $caching, $cache_lifetime);
|
||
|
|
||
|
$tpl->inheritance = $this->getInheritance(); // re-use the same Inheritance object inside the inheritance tree
|
||
|
|
||
|
if ($scope) {
|
||
|
$tpl->defaultScope = $scope;
|
||
|
}
|
||
|
|
||
|
if ($caching) {
|
||
|
if ($tpl->templateId !== $this->templateId && $caching !== \Smarty\Template::CACHING_NOCACHE_CODE) {
|
||
|
$tpl->getCached(true);
|
||
|
} else {
|
||
|
// re-use the same Cache object across subtemplates to gather hashes and file dependencies.
|
||
|
$tpl->setCached($this->getCached());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
foreach ($extra_vars as $_key => $_val) {
|
||
|
$tpl->assign($_key, $_val);
|
||
|
}
|
||
|
if ($tpl->caching === \Smarty\Template::CACHING_NOCACHE_CODE) {
|
||
|
if ($tpl->getCompiled()->getNocacheCode()) {
|
||
|
$this->getCached()->hashes[$tpl->getCompiled()->nocache_hash] = true;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
$tpl->render();
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Remove type indicator from resource name if present.
|
||
|
* E.g. $this->parseResourceName('file:template.tpl') returns 'template.tpl'
|
||
|
*
|
||
|
* @note "C:/foo.tpl" was forced to file resource up till Smarty 3.1.3 (including).
|
||
|
*
|
||
|
* @param string $resource_name template_resource or config_resource to parse
|
||
|
*
|
||
|
* @return string
|
||
|
*/
|
||
|
private function parseResourceName($resource_name): string {
|
||
|
if (preg_match('/^([A-Za-z0-9_\-]{2,}):/', $resource_name, $match)) {
|
||
|
return substr($resource_name, strlen($match[0]));
|
||
|
}
|
||
|
return $resource_name;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Check if this is a sub template
|
||
|
*
|
||
|
* @return bool true is sub template
|
||
|
*/
|
||
|
public function _isSubTpl() {
|
||
|
return isset($this->parent) && $this->parent instanceof Template;
|
||
|
}
|
||
|
|
||
|
public function assign($tpl_var, $value = null, $nocache = false, $scope = null) {
|
||
|
return parent::assign($tpl_var, $value, $nocache, $scope);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Compiles the template
|
||
|
* If the template is not evaluated the compiled template is saved on disk
|
||
|
*
|
||
|
* @TODO only used in compileAll and 1 unit test: can we move this and make compileAndWrite private?
|
||
|
*
|
||
|
* @throws \Exception
|
||
|
*/
|
||
|
public function compileTemplateSource() {
|
||
|
return $this->getCompiled()->compileAndWrite($this);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Return cached content
|
||
|
*
|
||
|
* @return null|string
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function getCachedContent() {
|
||
|
return $this->getCached()->getContent($this);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Writes the content to cache resource
|
||
|
*
|
||
|
* @param string $content
|
||
|
*
|
||
|
* @return bool
|
||
|
*
|
||
|
* @TODO this method is only used in unit tests that (mostly) try to test CacheResources.
|
||
|
*/
|
||
|
public function writeCachedContent($content) {
|
||
|
if ($this->getSource()->handler->recompiled || !$this->caching
|
||
|
) {
|
||
|
// don't write cache file
|
||
|
return false;
|
||
|
}
|
||
|
$codeframe = $this->createCodeFrame($content, '', true);
|
||
|
return $this->getCached()->writeCache($this, $codeframe);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Get unique template id
|
||
|
*
|
||
|
* @return string
|
||
|
*/
|
||
|
public function getTemplateId() {
|
||
|
return $this->templateId;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* runtime error not matching capture tags
|
||
|
*
|
||
|
* @throws \Smarty\Exception
|
||
|
*/
|
||
|
public function capture_error() {
|
||
|
throw new Exception("Not matching {capture} open/close in '{$this->template_resource}'");
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Return Compiled object
|
||
|
*
|
||
|
* @param bool $forceNew force new compiled object
|
||
|
*/
|
||
|
public function getCompiled($forceNew = false) {
|
||
|
if ($forceNew || !isset($this->compiled)) {
|
||
|
$this->compiled = Compiled::load($this);
|
||
|
}
|
||
|
return $this->compiled;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Return Cached object
|
||
|
*
|
||
|
* @param bool $forceNew force new cached object
|
||
|
*
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function getCached($forceNew = false): Cached {
|
||
|
if ($forceNew || !isset($this->cached)) {
|
||
|
$cacheResource = $this->smarty->getCacheResource();
|
||
|
$this->cached = new Cached(
|
||
|
$this->source,
|
||
|
$cacheResource,
|
||
|
$this->compile_id,
|
||
|
$this->cache_id
|
||
|
);
|
||
|
if ($this->isCachingEnabled()) {
|
||
|
$cacheResource->populate($this->cached, $this);
|
||
|
} else {
|
||
|
$this->cached->setValid(false);
|
||
|
}
|
||
|
}
|
||
|
return $this->cached;
|
||
|
}
|
||
|
|
||
|
private function isCachingEnabled(): bool {
|
||
|
return $this->caching && !$this->getSource()->handler->recompiled;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Helper function for InheritanceRuntime object
|
||
|
*
|
||
|
* @return InheritanceRuntime
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function getInheritance(): InheritanceRuntime {
|
||
|
if (is_null($this->inheritance)) {
|
||
|
$this->inheritance = clone $this->getSmarty()->getRuntime('Inheritance');
|
||
|
}
|
||
|
return $this->inheritance;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Sets a new InheritanceRuntime object.
|
||
|
*
|
||
|
* @param InheritanceRuntime $inheritanceRuntime
|
||
|
*
|
||
|
* @return void
|
||
|
*/
|
||
|
public function setInheritance(InheritanceRuntime $inheritanceRuntime) {
|
||
|
$this->inheritance = $inheritanceRuntime;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Return Compiler object
|
||
|
*/
|
||
|
public function getCompiler() {
|
||
|
if (!isset($this->compiler)) {
|
||
|
$this->compiler = $this->getSource()->createCompiler();
|
||
|
}
|
||
|
return $this->compiler;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Create code frame for compiled and cached templates
|
||
|
*
|
||
|
* @param string $content optional template content
|
||
|
* @param string $functions compiled template function and block code
|
||
|
* @param bool $cache flag for cache file
|
||
|
* @param Compiler\Template|null $compiler
|
||
|
*
|
||
|
* @return string
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function createCodeFrame($content = '', $functions = '', $cache = false, ?\Smarty\Compiler\Template $compiler = null) {
|
||
|
return $this->getCodeFrameCompiler()->create($content, $functions, $cache, $compiler);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Template data object destructor
|
||
|
*/
|
||
|
public function __destruct() {
|
||
|
if ($this->smarty->cache_locking && $this->getCached()->is_locked) {
|
||
|
$this->getCached()->handler->releaseLock($this->smarty, $this->getCached());
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Returns if the current template must be compiled by the Smarty compiler
|
||
|
* It does compare the timestamps of template source and the compiled templates and checks the force compile
|
||
|
* configuration
|
||
|
*
|
||
|
* @return bool
|
||
|
* @throws \Smarty\Exception
|
||
|
*/
|
||
|
public function mustCompile(): bool {
|
||
|
if (!$this->getSource()->exists) {
|
||
|
if ($this->_isSubTpl()) {
|
||
|
$parent_resource = " in '{$this->parent->template_resource}'";
|
||
|
} else {
|
||
|
$parent_resource = '';
|
||
|
}
|
||
|
throw new Exception("Unable to load {$this->getSource()->type} '{$this->getSource()->name}'{$parent_resource}");
|
||
|
}
|
||
|
|
||
|
// @TODO move this logic to Compiled
|
||
|
return $this->smarty->force_compile
|
||
|
|| $this->getSource()->handler->recompiled
|
||
|
|| !$this->getCompiled()->exists
|
||
|
|| ($this->compile_check && $this->getCompiled()->getTimeStamp() < $this->getSource()->getTimeStamp());
|
||
|
}
|
||
|
|
||
|
private function getCodeFrameCompiler(): Compiler\CodeFrame {
|
||
|
return new \Smarty\Compiler\CodeFrame($this);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Get left delimiter
|
||
|
*
|
||
|
* @return string
|
||
|
*/
|
||
|
public function getLeftDelimiter()
|
||
|
{
|
||
|
return $this->left_delimiter ?? $this->getSmarty()->getLeftDelimiter();
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Set left delimiter
|
||
|
*
|
||
|
* @param string $left_delimiter
|
||
|
*/
|
||
|
public function setLeftDelimiter($left_delimiter)
|
||
|
{
|
||
|
$this->left_delimiter = $left_delimiter;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Get right delimiter
|
||
|
*
|
||
|
* @return string $right_delimiter
|
||
|
*/
|
||
|
public function getRightDelimiter()
|
||
|
{
|
||
|
return $this->right_delimiter ?? $this->getSmarty()->getRightDelimiter();;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Set right delimiter
|
||
|
*
|
||
|
* @param string
|
||
|
*/
|
||
|
public function setRightDelimiter($right_delimiter)
|
||
|
{
|
||
|
$this->right_delimiter = $right_delimiter;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* gets a stream variable
|
||
|
*
|
||
|
* @param string $variable the stream of the variable
|
||
|
*
|
||
|
* @return mixed
|
||
|
* @throws \Smarty\Exception
|
||
|
*
|
||
|
*/
|
||
|
public function getStreamVariable($variable)
|
||
|
{
|
||
|
|
||
|
trigger_error("Using stream variables (\`\{\$foo:bar\}\`)is deprecated.", E_USER_DEPRECATED);
|
||
|
|
||
|
$_result = '';
|
||
|
$fp = fopen($variable, 'r+');
|
||
|
if ($fp) {
|
||
|
while (!feof($fp) && ($current_line = fgets($fp)) !== false) {
|
||
|
$_result .= $current_line;
|
||
|
}
|
||
|
fclose($fp);
|
||
|
return $_result;
|
||
|
}
|
||
|
if ($this->getSmarty()->error_unassigned) {
|
||
|
throw new Exception('Undefined stream variable "' . $variable . '"');
|
||
|
}
|
||
|
return null;
|
||
|
}
|
||
|
/**
|
||
|
* @inheritdoc
|
||
|
*/
|
||
|
public function configLoad($config_file, $sections = null)
|
||
|
{
|
||
|
$confObj = parent::configLoad($config_file, $sections);
|
||
|
|
||
|
$this->getCompiled()->file_dependency[ $confObj->getSource()->uid ] =
|
||
|
array($confObj->getSource()->getResourceName(), $confObj->getSource()->getTimeStamp(), $confObj->getSource()->type);
|
||
|
|
||
|
return $confObj;
|
||
|
}
|
||
|
|
||
|
public function fetch() {
|
||
|
$result = $this->_execute(0);
|
||
|
return $result === null ? ob_get_clean() : $result;
|
||
|
}
|
||
|
|
||
|
public function display() {
|
||
|
$this->_execute(1);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* test if cache is valid
|
||
|
*
|
||
|
* @param mixed $cache_id cache id to be used with this template
|
||
|
* @param mixed $compile_id compile id to be used with this template
|
||
|
* @param object $parent next higher level of Smarty variables
|
||
|
*
|
||
|
* @return bool cache status
|
||
|
* @throws \Exception
|
||
|
* @throws \Smarty\Exception
|
||
|
*
|
||
|
* @api Smarty::isCached()
|
||
|
*/
|
||
|
public function isCached(): bool {
|
||
|
return (bool) $this->_execute(2);
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* fetches a rendered Smarty template
|
||
|
*
|
||
|
* @param string $function function type 0 = fetch, 1 = display, 2 = isCache
|
||
|
*
|
||
|
* @return mixed
|
||
|
* @throws Exception
|
||
|
* @throws \Throwable
|
||
|
*/
|
||
|
private function _execute($function) {
|
||
|
|
||
|
$smarty = $this->getSmarty();
|
||
|
|
||
|
// make sure we have integer values
|
||
|
$this->caching = (int)$this->caching;
|
||
|
// fetch template content
|
||
|
$level = ob_get_level();
|
||
|
try {
|
||
|
$_smarty_old_error_level =
|
||
|
isset($smarty->error_reporting) ? error_reporting($smarty->error_reporting) : null;
|
||
|
|
||
|
if ($smarty->isMutingUndefinedOrNullWarnings()) {
|
||
|
$errorHandler = new \Smarty\ErrorHandler();
|
||
|
$errorHandler->activate();
|
||
|
}
|
||
|
|
||
|
if ($function === 2) {
|
||
|
if ($this->caching) {
|
||
|
// return cache status of template
|
||
|
$result = $this->getCached()->isCached($this);
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
} else {
|
||
|
|
||
|
// After rendering a template, the tpl/config variables are reset, so the template can be re-used.
|
||
|
$this->pushStack();
|
||
|
|
||
|
// Start output-buffering.
|
||
|
ob_start();
|
||
|
|
||
|
$result = $this->render(false, $function);
|
||
|
|
||
|
// Restore the template to its previous state
|
||
|
$this->popStack();
|
||
|
}
|
||
|
|
||
|
if (isset($errorHandler)) {
|
||
|
$errorHandler->deactivate();
|
||
|
}
|
||
|
|
||
|
if (isset($_smarty_old_error_level)) {
|
||
|
error_reporting($_smarty_old_error_level);
|
||
|
}
|
||
|
return $result;
|
||
|
} catch (\Throwable $e) {
|
||
|
while (ob_get_level() > $level) {
|
||
|
ob_end_clean();
|
||
|
}
|
||
|
if (isset($errorHandler)) {
|
||
|
$errorHandler->deactivate();
|
||
|
}
|
||
|
|
||
|
if (isset($_smarty_old_error_level)) {
|
||
|
error_reporting($_smarty_old_error_level);
|
||
|
}
|
||
|
throw $e;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* @return Config|Source|null
|
||
|
*/
|
||
|
public function getSource() {
|
||
|
return $this->source;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* @param Config|Source|null $source
|
||
|
*/
|
||
|
public function setSource($source): void {
|
||
|
$this->source = $source;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* Sets the Cached object, so subtemplates can share one Cached object to gather meta-data.
|
||
|
*
|
||
|
* @param Cached $cached
|
||
|
*
|
||
|
* @return void
|
||
|
*/
|
||
|
private function setCached(Cached $cached) {
|
||
|
$this->cached = $cached;
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* @param string $compile_id
|
||
|
*
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function setCompileId($compile_id) {
|
||
|
parent::setCompileId($compile_id);
|
||
|
$this->getCompiled(true);
|
||
|
if ($this->caching) {
|
||
|
$this->getCached(true);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/**
|
||
|
* @param string $cache_id
|
||
|
*
|
||
|
* @throws Exception
|
||
|
*/
|
||
|
public function setCacheId($cache_id) {
|
||
|
parent::setCacheId($cache_id);
|
||
|
$this->getCached(true);
|
||
|
}
|
||
|
|
||
|
}
|