lib/api/smarty/sysplugins/smarty_internal_template.php

   1 <?php
   2 /**
   3  * Smarty Internal Plugin Template
   4  * This file contains the Smarty template engine
   5  *
   6  * @package    Smarty
   7  * @subpackage Template
   8  * @author     Uwe Tews
   9  */
  10
  11 /**
  12  * Main class with template data structures and methods
  13  *
  14  * @package    Smarty
  15  * @subpackage Template
  16  * @property Smarty_Template_Source   $source
  17  * @property Smarty_Template_Compiled $compiled
  18  * @property Smarty_Template_Cached   $cached
  19  */
  20 class Smarty_Internal_Template extends Smarty_Internal_TemplateBase
  21 {
  22     /**
  23      * cache_id
  24      *
  25      * @var string
  26      */
  27     public $cache_id = null;
  28     /**
  29      * $compile_id
  30      * @var string
  31      */
  32     public $compile_id = null;
  33     /**
  34      * caching enabled
  35      *
  36      * @var boolean
  37      */
  38     public $caching = null;
  39     /**
  40      * cache lifetime in seconds
  41      *
  42      * @var integer
  43      */
  44     public $cache_lifetime = null;
  45     /**
  46      * Template resource
  47      *
  48      * @var string
  49      */
  50     public $template_resource = null;
  51     /**
  52      * flag if compiled template is invalid and must be (re)compiled
  53      *
  54      * @var bool
  55      */
  56     public $mustCompile = null;
  57     /**
  58      * flag if template does contain nocache code sections
  59      *
  60      * @var bool
  61      */
  62     public $has_nocache_code = false;
  63     /**
  64      * special compiled and cached template properties
  65      *
  66      * @var array
  67      */
  68     public $properties = array('file_dependency' => array(),
  69                                'nocache_hash'    => '',
  70                                'function'        => array());
  71     /**
  72      * required plugins
  73      *
  74      * @var array
  75      */
  76     public $required_plugins = array('compiled' => array(), 'nocache' => array());
  77     /**
  78      * Global smarty instance
  79      *
  80      * @var Smarty
  81      */
  82     public $smarty = null;
  83     /**
  84      * blocks for template inheritance
  85      *
  86      * @var array
  87      */
  88     public $block_data = array();
  89     /**
  90      * variable filters
  91      *
  92      * @var array
  93      */
  94     public $variable_filters = array();
  95     /**
  96      * optional log of tag/attributes
  97      *
  98      * @var array
  99      */
 100     public $used_tags = array();
 101     /**
 102      * internal flag to allow relative path in child template blocks
 103      *
 104      * @var bool
 105      */
 106     public $allow_relative_path = false;
 107     /**
 108      * internal capture runtime stack
 109      *
 110      * @var array
 111      */
 112     public $_capture_stack = array(0 => array());
 113
 114     /**
 115      * Create template data object
 116      * Some of the global Smarty settings copied to template scope
 117      * It load the required template resources and cacher plugins
 118      *
 119      * @param string                   $template_resource template resource string
 120      * @param Smarty                   $smarty            Smarty instance
 121      * @param Smarty_Internal_Template $_parent           back pointer to parent object with variables or null
 122      * @param mixed                    $_cache_id         cache   id or null
 123      * @param mixed                    $_compile_id       compile id or null
 124      * @param bool                     $_caching          use caching?
 125      * @param int                      $_cache_lifetime   cache life-time in seconds
 126      */
 127     public function __construct($template_resource, $smarty, $_parent = null, $_cache_id = null, $_compile_id = null, $_caching = null, $_cache_lifetime = null)
 128     {
 129         $this->smarty = & $smarty;
 130         // Smarty parameter
 131         $this->cache_id = $_cache_id === null ? $this->smarty->cache_id : $_cache_id;
 132         $this->compile_id = $_compile_id === null ? $this->smarty->compile_id : $_compile_id;
 133         $this->caching = $_caching === null ? $this->smarty->caching : $_caching;
 134         if ($this->caching === true) {
 135             $this->caching = Smarty::CACHING_LIFETIME_CURRENT;
 136         }
 137         $this->cache_lifetime = $_cache_lifetime === null ? $this->smarty->cache_lifetime : $_cache_lifetime;
 138         $this->parent = $_parent;
 139         // Template resource
 140         $this->template_resource = $template_resource;
 141         // copy block data of template inheritance
 142         if ($this->parent instanceof Smarty_Internal_Template) {
 143             $this->block_data = $this->parent->block_data;
 144         }
 145     }
 146
 147     /**
 148      * Returns if the current template must be compiled by the Smarty compiler
 149      * It does compare the timestamps of template source and the compiled templates and checks the force compile configuration
 150      *
 151      * @throws SmartyException
 152      * @return boolean true if the template must be compiled
 153      */
 154     public function mustCompile()
 155     {
 156         if (!$this->source->exists) {
 157             if ($this->parent instanceof Smarty_Internal_Template) {
 158                 $parent_resource = " in '$this->parent->template_resource}'";
 159             } else {
 160                 $parent_resource = '';
 161             }
 162             throw new SmartyException("Unable to load template {$this->source->type} '{$this->source->name}'{$parent_resource}");
 163         }
 164         if ($this->mustCompile === null) {
 165             $this->mustCompile = (!$this->source->uncompiled && ($this->smarty->force_compile || $this->source->recompiled || $this->compiled->timestamp === false ||
 166                     ($this->smarty->compile_check && $this->compiled->timestamp < $this->source->timestamp)));
 167         }
 168
 169         return $this->mustCompile;
 170     }
 171
 172     /**
 173      * Compiles the template
 174      * If the template is not evaluated the compiled template is saved on disk
 175      */
 176     public function compileTemplateSource()
 177     {
 178         if (!$this->source->recompiled) {
 179             $this->properties['file_dependency'] = array();
 180             if ($this->source->components) {
 181                 // for the extends resource the compiler will fill it
 182                 // uses real resource for file dependency
 183                 // $source = end($this->source->components);
 184                 // $this->properties['file_dependency'][$this->source->uid] = array($this->source->filepath, $this->source->timestamp, $source->type);
 185             } else {
 186                 $this->properties['file_dependency'][$this->source->uid] = array($this->source->filepath, $this->source->timestamp, $this->source->type);
 187             }
 188         }
 189         // compile locking
 190         if ($this->smarty->compile_locking && !$this->source->recompiled) {
 191             if ($saved_timestamp = $this->compiled->timestamp) {
 192                 touch($this->compiled->filepath);
 193             }
 194         }
 195         // call compiler
 196         try {
 197             $code = $this->compiler->compileTemplate($this);
 198         }
 199         catch (Exception $e) {
 200             // restore old timestamp in case of error
 201             if ($this->smarty->compile_locking && !$this->source->recompiled && $saved_timestamp) {
 202                 touch($this->compiled->filepath, $saved_timestamp);
 203             }
 204             throw $e;
 205         }
 206         // compiling succeded
 207         if (!$this->source->recompiled && $this->compiler->write_compiled_code) {
 208             // write compiled template
 209             $_filepath = $this->compiled->filepath;
 210             if ($_filepath === false) {
 211                 throw new SmartyException('getCompiledFilepath() did not return a destination to save the compiled template to');
 212             }
 213             Smarty_Internal_Write_File::writeFile($_filepath, $code, $this->smarty);
 214             $this->compiled->exists = true;
 215             $this->compiled->isCompiled = true;
 216         }
 217         // release compiler object to free memory
 218         unset($this->compiler);
 219     }
 220
 221     /**
 222      * Writes the cached template output
 223      *
 224      * @param string $content
 225      *
 226      * @return bool
 227      */
 228     public function writeCachedContent($content)
 229     {
 230         if ($this->source->recompiled || !($this->caching == Smarty::CACHING_LIFETIME_CURRENT || $this->caching == Smarty::CACHING_LIFETIME_SAVED)) {
 231             // don't write cache file
 232             return false;
 233         }
 234         $this->cached->timestamp = time();
 235         $this->properties['cache_lifetime'] = $this->cache_lifetime;
 236         $this->properties['unifunc'] = 'content_' . str_replace(array('.', ','), '_', uniqid('', true));
 237         $content = $this->createTemplateCodeFrame($content, true);
 238         /** @var Smarty_Internal_Template $_smarty_tpl
 239          * used in evaluated code
 240          */
 241         $_smarty_tpl = $this;
 242         eval("?>" . $content);
 243         $this->cached->valid = true;
 244         $this->cached->processed = true;
 245
 246         return $this->cached->write($this, $content);
 247     }
 248
 249     /**
 250      * Template code runtime function to get subtemplate content
 251      *
 252      * @param string  $template       the resource handle of the template file
 253      * @param mixed   $cache_id       cache id to be used with this template
 254      * @param mixed   $compile_id     compile id to be used with this template
 255      * @param integer $caching        cache mode
 256      * @param integer $cache_lifetime life time of cache data
 257      * @param         $data
 258      * @param int     $parent_scope   scope in which {include} should execute
 259      *
 260      * @returns string template content
 261      */
 262     public function getSubTemplate($template, $cache_id, $compile_id, $caching, $cache_lifetime, $data, $parent_scope)
 263     {
 264         // already in template cache?
 265         if ($this->smarty->allow_ambiguous_resources) {
 266             $_templateId = Smarty_Resource::getUniqueTemplateName($this, $template) . $cache_id . $compile_id;
 267         } else {
 268             $_templateId = $this->smarty->joined_template_dir . '#' . $template . $cache_id . $compile_id;
 269         }
 270
 271         if (isset($_templateId[150])) {
 272             $_templateId = sha1($_templateId);
 273         }
 274         if (isset($this->smarty->template_objects[$_templateId])) {
 275             // clone cached template object because of possible recursive call
 276             $tpl = clone $this->smarty->template_objects[$_templateId];
 277             $tpl->parent = $this;
 278             $tpl->caching = $caching;
 279             $tpl->cache_lifetime = $cache_lifetime;
 280         } else {
 281             $tpl = new $this->smarty->template_class($template, $this->smarty, $this, $cache_id, $compile_id, $caching, $cache_lifetime);
 282         }
 283         // get variables from calling scope
 284         if ($parent_scope == Smarty::SCOPE_LOCAL) {
 285             $tpl->tpl_vars = $this->tpl_vars;
 286             $tpl->tpl_vars['smarty'] = clone $this->tpl_vars['smarty'];
 287         } elseif ($parent_scope == Smarty::SCOPE_PARENT) {
 288             $tpl->tpl_vars = & $this->tpl_vars;
 289         } elseif ($parent_scope == Smarty::SCOPE_GLOBAL) {
 290             $tpl->tpl_vars = & Smarty::$global_tpl_vars;
 291         } elseif (($scope_ptr = $this->getScopePointer($parent_scope)) == null) {
 292             $tpl->tpl_vars = & $this->tpl_vars;
 293         } else {
 294             $tpl->tpl_vars = & $scope_ptr->tpl_vars;
 295         }
 296         $tpl->config_vars = $this->config_vars;
 297         if (!empty($data)) {
 298             // set up variable values
 299             foreach ($data as $_key => $_val) {
 300                 $tpl->tpl_vars[$_key] = new Smarty_variable($_val);
 301             }
 302         }
 303
 304         return $tpl->fetch(null, null, null, null, false, false, true);
 305     }
 306
 307     /**
 308      * Template code runtime function to set up an inline subtemplate
 309      *
 310      * @param string  $template       the resource handle of the template file
 311      * @param mixed   $cache_id       cache id to be used with this template
 312      * @param mixed   $compile_id     compile id to be used with this template
 313      * @param integer $caching        cache mode
 314      * @param integer $cache_lifetime life time of cache data
 315      * @param         $data
 316      * @param int     $parent_scope   scope in which {include} should execute
 317      * @param string  $hash           nocache hash code
 318      *
 319      * @returns string template content
 320      */
 321     public function setupInlineSubTemplate($template, $cache_id, $compile_id, $caching, $cache_lifetime, $data, $parent_scope, $hash)
 322     {
 323         $tpl = new $this->smarty->template_class($template, $this->smarty, $this, $cache_id, $compile_id, $caching, $cache_lifetime);
 324         $tpl->properties['nocache_hash'] = $hash;
 325         // get variables from calling scope
 326         if ($parent_scope == Smarty::SCOPE_LOCAL) {
 327             $tpl->tpl_vars = $this->tpl_vars;
 328             $tpl->tpl_vars['smarty'] = clone $this->tpl_vars['smarty'];
 329         } elseif ($parent_scope == Smarty::SCOPE_PARENT) {
 330             $tpl->tpl_vars = & $this->tpl_vars;
 331         } elseif ($parent_scope == Smarty::SCOPE_GLOBAL) {
 332             $tpl->tpl_vars = & Smarty::$global_tpl_vars;
 333         } elseif (($scope_ptr = $this->getScopePointer($parent_scope)) == null) {
 334             $tpl->tpl_vars = & $this->tpl_vars;
 335         } else {
 336             $tpl->tpl_vars = & $scope_ptr->tpl_vars;
 337         }
 338         $tpl->config_vars = $this->config_vars;
 339         if (!empty($data)) {
 340             // set up variable values
 341             foreach ($data as $_key => $_val) {
 342                 $tpl->tpl_vars[$_key] = new Smarty_variable($_val);
 343             }
 344         }
 345
 346         return $tpl;
 347     }
 348
 349     /**
 350      * Create code frame for compiled and cached templates
 351      *
 352      * @param  string $content optional template content
 353      * @param  bool   $cache   flag for cache file
 354      *
 355      * @return string
 356      */
 357     public function createTemplateCodeFrame($content = '', $cache = false)
 358     {
 359         $plugins_string = '';
 360         // include code for plugins
 361         if (!$cache) {
 362             if (!empty($this->required_plugins['compiled'])) {
 363                 $plugins_string = '<?php ';
 364                 foreach ($this->required_plugins['compiled'] as $tmp) {
 365                     foreach ($tmp as $data) {
 366                         $file = addslashes($data['file']);
 367                         if (is_Array($data['function'])) {
 368                             $plugins_string .= "if (!is_callable(array('{$data['function'][0]}','{$data['function'][1]}'))) include '{$file}';\n";
 369                         } else {
 370                             $plugins_string .= "if (!is_callable('{$data['function']}')) include '{$file}';\n";
 371                         }
 372                     }
 373                 }
 374                 $plugins_string .= '?>';
 375             }
 376             if (!empty($this->required_plugins['nocache'])) {
 377                 $this->has_nocache_code = true;
 378                 $plugins_string .= "<?php echo '/*%%SmartyNocache:{$this->properties['nocache_hash']}%%*/<?php \$_smarty = \$_smarty_tpl->smarty; ";
 379                 foreach ($this->required_plugins['nocache'] as $tmp) {
 380                     foreach ($tmp as $data) {
 381                         $file = addslashes($data['file']);
 382                         if (is_Array($data['function'])) {
 383                             $plugins_string .= addslashes("if (!is_callable(array('{$data['function'][0]}','{$data['function'][1]}'))) include '{$file}';\n");
 384                         } else {
 385                             $plugins_string .= addslashes("if (!is_callable('{$data['function']}')) include '{$file}';\n");
 386                         }
 387                     }
 388                 }
 389                 $plugins_string .= "?>/*/%%SmartyNocache:{$this->properties['nocache_hash']}%%*/';?>\n";
 390             }
 391         }
 392         // build property code
 393         $this->properties['has_nocache_code'] = $this->has_nocache_code;
 394         $output = '';
 395         if (!$this->source->recompiled) {
 396             $output = "<?php /*%%SmartyHeaderCode:{$this->properties['nocache_hash']}%%*/";
 397             if ($this->smarty->direct_access_security) {
 398                 $output .= "if(!defined('SMARTY_DIR')) exit('no direct access allowed');\n";
 399             }
 400         }
 401         if ($cache) {
 402             // remove compiled code of{function} definition
 403             unset($this->properties['function']);
 404             if (!empty($this->smarty->template_functions)) {
 405                 // copy code of {function} tags called in nocache mode
 406                 foreach ($this->smarty->template_functions as $name => $function_data) {
 407                     if (isset($function_data['called_nocache'])) {
 408                         foreach ($function_data['called_functions'] as $func_name) {
 409                             $this->smarty->template_functions[$func_name]['called_nocache'] = true;
 410                         }
 411                     }
 412                 }
 413                 foreach ($this->smarty->template_functions as $name => $function_data) {
 414                     if (isset($function_data['called_nocache'])) {
 415                         unset($function_data['called_nocache'], $function_data['called_functions'], $this->smarty->template_functions[$name]['called_nocache']);
 416                         $this->properties['function'][$name] = $function_data;
 417                     }
 418                 }
 419             }
 420         }
 421         $this->properties['version'] = Smarty::SMARTY_VERSION;
 422         if (!isset($this->properties['unifunc'])) {
 423             $this->properties['unifunc'] = 'content_' . str_replace(array('.', ','), '_', uniqid('', true));
 424         }
 425         if (!$this->source->recompiled) {
 426             $output .= "\$_valid = \$_smarty_tpl->decodeProperties(" . var_export($this->properties, true) . ',' . ($cache ? 'true' : 'false') . "); /*/%%SmartyHeaderCode%%*/?>\n";
 427             $output .= '<?php if ($_valid && !is_callable(\'' . $this->properties['unifunc'] . '\')) {function ' . $this->properties['unifunc'] . '($_smarty_tpl) {?>';
 428         }
 429         $output .= $plugins_string;
 430         $output .= $content;
 431         if (!$this->source->recompiled) {
 432             $output .= "<?php }} ?>\n";
 433         }
 434
 435         return $output;
 436     }
 437
 438     /**
 439      * This function is executed automatically when a compiled or cached template file is included
 440      * - Decode saved properties from compiled template and cache files
 441      * - Check if compiled or cache file is valid
 442      *
 443      * @param  array $properties special template properties
 444      * @param  bool  $cache      flag if called from cache file
 445      *
 446      * @return bool  flag if compiled or cache file is valid
 447      */
 448     public function decodeProperties($properties, $cache = false)
 449     {
 450         $this->has_nocache_code = $properties['has_nocache_code'];
 451         $this->properties['nocache_hash'] = $properties['nocache_hash'];
 452         if (isset($properties['cache_lifetime'])) {
 453             $this->properties['cache_lifetime'] = $properties['cache_lifetime'];
 454         }
 455         if (isset($properties['file_dependency'])) {
 456             $this->properties['file_dependency'] = array_merge($this->properties['file_dependency'], $properties['file_dependency']);
 457         }
 458         if (!empty($properties['function'])) {
 459             $this->properties['function'] = array_merge($this->properties['function'], $properties['function']);
 460             $this->smarty->template_functions = array_merge($this->smarty->template_functions, $properties['function']);
 461         }
 462         $this->properties['version'] = (isset($properties['version'])) ? $properties['version'] : '';
 463         $this->properties['unifunc'] = $properties['unifunc'];
 464         // check file dependencies at compiled code
 465         $is_valid = true;
 466         if ($this->properties['version'] != Smarty::SMARTY_VERSION) {
 467             $is_valid = false;
 468         } elseif (((!$cache && $this->smarty->compile_check && empty($this->compiled->_properties) && !$this->compiled->isCompiled) || $cache && ($this->smarty->compile_check === true || $this->smarty->compile_check === Smarty::COMPILECHECK_ON)) && !empty($this->properties['file_dependency'])) {
 469             foreach ($this->properties['file_dependency'] as $_file_to_check) {
 470                 if ($_file_to_check[2] == 'file' || $_file_to_check[2] == 'php') {
 471                     if ($this->source->filepath == $_file_to_check[0] && isset($this->source->timestamp)) {
 472                         // do not recheck current template
 473                         $mtime = $this->source->timestamp;
 474                     } else {
 475                         // file and php types can be checked without loading the respective resource handlers
 476                         $mtime = @filemtime($_file_to_check[0]);
 477                     }
 478                 } elseif ($_file_to_check[2] == 'string') {
 479                     continue;
 480                 } else {
 481                     $source = Smarty_Resource::source(null, $this->smarty, $_file_to_check[0]);
 482                     $mtime = $source->timestamp;
 483                 }
 484                 if (!$mtime || $mtime > $_file_to_check[1]) {
 485                     $is_valid = false;
 486                     break;
 487                 }
 488             }
 489         }
 490         if ($cache) {
 491             // CACHING_LIFETIME_SAVED cache expiry has to be validated here since otherwise we'd define the unifunc
 492             if ($this->caching === Smarty::CACHING_LIFETIME_SAVED &&
 493                 $this->properties['cache_lifetime'] >= 0 &&
 494                 (time() > ($this->cached->timestamp + $this->properties['cache_lifetime']))
 495             ) {
 496                 $is_valid = false;
 497             }
 498             $this->cached->valid = $is_valid;
 499         } else {
 500             $this->mustCompile = !$is_valid;
 501         }
 502         // store data in reusable Smarty_Template_Compiled
 503         if (!$cache) {
 504             $this->compiled->_properties = $properties;
 505         }
 506
 507         return $is_valid;
 508     }
 509
 510     /**
 511      * Template code runtime function to create a local Smarty variable for array assignments
 512      *
 513      * @param string $tpl_var tempate variable name
 514      * @param bool   $nocache cache mode of variable
 515      * @param int    $scope   scope of variable
 516      */
 517     public function createLocalArrayVariable($tpl_var, $nocache = false, $scope = Smarty::SCOPE_LOCAL)
 518     {
 519         if (!isset($this->tpl_vars[$tpl_var])) {
 520             $this->tpl_vars[$tpl_var] = new Smarty_variable(array(), $nocache, $scope);
 521         } else {
 522             $this->tpl_vars[$tpl_var] = clone $this->tpl_vars[$tpl_var];
 523             if ($scope != Smarty::SCOPE_LOCAL) {
 524                 $this->tpl_vars[$tpl_var]->scope = $scope;
 525             }
 526             if (!(is_array($this->tpl_vars[$tpl_var]->value) || $this->tpl_vars[$tpl_var]->value instanceof ArrayAccess)) {
 527                 settype($this->tpl_vars[$tpl_var]->value, 'array');
 528             }
 529         }
 530     }
 531
 532     /**
 533      * Template code runtime function to get pointer to template variable array of requested scope
 534      *
 535      * @param  int $scope requested variable scope
 536      *
 537      * @return array array of template variables
 538      */
 539     public function &getScope($scope)
 540     {
 541         if ($scope == Smarty::SCOPE_PARENT && !empty($this->parent)) {
 542             return $this->parent->tpl_vars;
 543         } elseif ($scope == Smarty::SCOPE_ROOT && !empty($this->parent)) {
 544             $ptr = $this->parent;
 545             while (!empty($ptr->parent)) {
 546                 $ptr = $ptr->parent;
 547             }
 548
 549             return $ptr->tpl_vars;
 550         } elseif ($scope == Smarty::SCOPE_GLOBAL) {
 551             return Smarty::$global_tpl_vars;
 552         }
 553         $null = null;
 554
 555         return $null;
 556     }
 557
 558     /**
 559      * Get parent or root of template parent chain
 560      *
 561      * @param  int $scope pqrent or root scope
 562      *
 563      * @return mixed object
 564      */
 565     public function getScopePointer($scope)
 566     {
 567         if ($scope == Smarty::SCOPE_PARENT && !empty($this->parent)) {
 568             return $this->parent;
 569         } elseif ($scope == Smarty::SCOPE_ROOT && !empty($this->parent)) {
 570             $ptr = $this->parent;
 571             while (!empty($ptr->parent)) {
 572                 $ptr = $ptr->parent;
 573             }
 574
 575             return $ptr;
 576         }
 577
 578         return null;
 579     }
 580
 581     /**
 582      * [util function] counts an array, arrayaccess/traversable or PDOStatement object
 583      *
 584      * @param  mixed $value
 585      *
 586      * @return int   the count for arrays and objects that implement countable, 1 for other objects that don't, and 0 for empty elements
 587      */
 588     public function _count($value)
 589     {
 590         if (is_array($value) === true || $value instanceof Countable) {
 591             return count($value);
 592         } elseif ($value instanceof IteratorAggregate) {
 593             // Note: getIterator() returns a Traversable, not an Iterator
 594             // thus rewind() and valid() methods may not be present
 595             return iterator_count($value->getIterator());
 596         } elseif ($value instanceof Iterator) {
 597             return iterator_count($value);
 598         } elseif ($value instanceof PDOStatement) {
 599             return $value->rowCount();
 600         } elseif ($value instanceof Traversable) {
 601             return iterator_count($value);
 602         } elseif ($value instanceof ArrayAccess) {
 603             if ($value->offsetExists(0)) {
 604                 return 1;
 605             }
 606         } elseif (is_object($value)) {
 607             return count($value);
 608         }
 609
 610         return 0;
 611     }
 612
 613     /**
 614      * runtime error not matching capture tags
 615
 616      */
 617     public function capture_error()
 618     {
 619         throw new SmartyException("Not matching {capture} open/close in \"{$this->template_resource}\"");
 620     }
 621
 622     /**
 623      * Empty cache for this template
 624      *
 625      * @param integer $exp_time expiration time
 626      *
 627      * @return integer number of cache files deleted
 628      */
 629     public function clearCache($exp_time = null)
 630     {
 631         Smarty_CacheResource::invalidLoadedCache($this->smarty);
 632
 633         return $this->cached->handler->clear($this->smarty, $this->template_name, $this->cache_id, $this->compile_id, $exp_time);
 634     }
 635
 636     /**
 637      * set Smarty property in template context
 638      *
 639      * @param string $property_name property name
 640      * @param mixed  $value         value
 641      *
 642      * @throws SmartyException
 643      */
 644     public function __set($property_name, $value)
 645     {
 646         switch ($property_name) {
 647             case 'source':
 648             case 'compiled':
 649             case 'cached':
 650             case 'compiler':
 651                 $this->$property_name = $value;
 652
 653                 return;
 654
 655             // FIXME: routing of template -> smarty attributes
 656             default:
 657                 if (property_exists($this->smarty, $property_name)) {
 658                     $this->smarty->$property_name = $value;
 659
 660                     return;
 661                 }
 662         }
 663
 664         throw new SmartyException("invalid template property '$property_name'.");
 665     }
 666
 667     /**
 668      * get Smarty property in template context
 669      *
 670      * @param string $property_name property name
 671      *
 672      * @throws SmartyException
 673      */
 674     public function __get($property_name)
 675     {
 676         switch ($property_name) {
 677             case 'source':
 678                 if (strlen($this->template_resource) == 0) {
 679                     throw new SmartyException('Missing template name');
 680                 }
 681                 $this->source = Smarty_Resource::source($this);
 682                 // cache template object under a unique ID
 683                 // do not cache eval resources
 684                 if ($this->source->type != 'eval') {
 685                     if ($this->smarty->allow_ambiguous_resources) {
 686                         $_templateId = $this->source->unique_resource . $this->cache_id . $this->compile_id;
 687                     } else {
 688                         $_templateId = $this->smarty->joined_template_dir . '#' . $this->template_resource . $this->cache_id . $this->compile_id;
 689                     }
 690
 691                     if (isset($_templateId[150])) {
 692                         $_templateId = sha1($_templateId);
 693                     }
 694                     $this->smarty->template_objects[$_templateId] = $this;
 695                 }
 696
 697                 return $this->source;
 698
 699             case 'compiled':
 700                 $this->compiled = $this->source->getCompiled($this);
 701
 702                 return $this->compiled;
 703
 704             case 'cached':
 705                 if (!class_exists('Smarty_Template_Cached')) {
 706                     include SMARTY_SYSPLUGINS_DIR . 'smarty_cacheresource.php';
 707                 }
 708                 $this->cached = new Smarty_Template_Cached($this);
 709
 710                 return $this->cached;
 711
 712             case 'compiler':
 713                 $this->smarty->loadPlugin($this->source->compiler_class);
 714                 $this->compiler = new $this->source->compiler_class($this->source->template_lexer_class, $this->source->template_parser_class, $this->smarty);
 715
 716                 return $this->compiler;
 717
 718             // FIXME: routing of template -> smarty attributes
 719             default:
 720                 if (property_exists($this->smarty, $property_name)) {
 721                     return $this->smarty->$property_name;
 722                 }
 723         }
 724
 725         throw new SmartyException("template property '$property_name' does not exist.");
 726     }
 727
 728     /**
 729      * Template data object destructor
 730
 731      */
 732     public function __destruct()
 733     {
 734         if ($this->smarty->cache_locking && isset($this->cached) && $this->cached->is_locked) {
 735             $this->cached->handler->releaseLock($this->smarty, $this->cached);
 736         }
 737     }
 738 }