1 <?php

     2 /**

     3  * Project:     Smarty: the PHP compiling template engine

     4  * File:        Smarty.class.php

     5  *

     6  * This library is free software; you can redistribute it and/or

     7  * modify it under the terms of the GNU Lesser General Public

     8  * License as published by the Free Software Foundation; either

     9  * version 2.1 of the License, or (at your option) any later version.

    10  *

    11  * This library is distributed in the hope that it will be useful,

    12  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    14  * Lesser General Public License for more details.

    15  *

    16  * You should have received a copy of the GNU Lesser General Public

    17  * License along with this library; if not, write to the Free Software

    18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    19  * For questions, help, comments, discussion, etc., please join the

    20  * Smarty mailing list. Send a blank e-mail to

    21  * smarty-discussion-subscribe@googlegroups.com

    22  *

    23  * @link      http://www.smarty.net/

    24  * @copyright 2015 New Digital Group, Inc.

    25  * @copyright 2015 Uwe Tews

    26  * @author    Monte Ohrt <monte at ohrt dot com>

    27  * @author    Uwe Tews

    28  * @author    Rodney Rehm

    29  * @package   Smarty

    30  * @version   3.1.27

    31  */

    32 

    33 /**

    34  * define shorthand directory separator constant

    35  */

    36 if (!defined('DS')) {

    37     define('DS', DIRECTORY_SEPARATOR);

    38 }

    39 

    40 /**

    41  * set SMARTY_DIR to absolute path to Smarty library files.

    42  * Sets SMARTY_DIR only if user application has not already defined it.

    43  */

    44 if (!defined('SMARTY_DIR')) {

    45     define('SMARTY_DIR', dirname(__FILE__) . DS);

    46 }

    47 

    48 /**

    49  * set SMARTY_SYSPLUGINS_DIR to absolute path to Smarty internal plugins.

    50  * Sets SMARTY_SYSPLUGINS_DIR only if user application has not already defined it.

    51  */

    52 if (!defined('SMARTY_SYSPLUGINS_DIR')) {

    53     define('SMARTY_SYSPLUGINS_DIR', SMARTY_DIR . 'sysplugins' . DS);

    54 }

    55 if (!defined('SMARTY_PLUGINS_DIR')) {

    56     define('SMARTY_PLUGINS_DIR', SMARTY_DIR . 'plugins' . DS);

    57 }

    58 if (!defined('SMARTY_MBSTRING')) {

    59     define('SMARTY_MBSTRING', function_exists('mb_get_info'));

    60 }

    61 if (!defined('SMARTY_RESOURCE_CHAR_SET')) {

    62     // UTF-8 can only be done properly when mbstring is available!

    63     /**

    64      * @deprecated in favor of Smarty::$_CHARSET

    65      */

    66     define('SMARTY_RESOURCE_CHAR_SET', SMARTY_MBSTRING ? 'UTF-8' : 'ISO-8859-1');

    67 }

    68 if (!defined('SMARTY_RESOURCE_DATE_FORMAT')) {

    69     /**

    70      * @deprecated in favor of Smarty::$_DATE_FORMAT

    71      */

    72     define('SMARTY_RESOURCE_DATE_FORMAT', '%b %e, %Y');

    73 }

    74 

    75 /**

    76  * Try loading the Smarty_Internal_Data class

    77  * If we fail we must load Smarty's autoloader.

    78  * Otherwise we may have a global autoloader like Composer

    79  */

    80 if (!class_exists('Smarty_Autoloader', false)) {

    81     if (!class_exists('Smarty_Internal_Data', true)) {

    82         require_once 'Autoloader.php';

    83         Smarty_Autoloader::registerBC();

    84     }

    85 }

    86 

    87 /**

    88  * Load always needed external class files

    89  */

    90 

    91 if (!class_exists('Smarty_Internal_Data', false)) {

    92     require_once SMARTY_SYSPLUGINS_DIR . 'smarty_internal_data.php';

    93 }

    94 require_once SMARTY_SYSPLUGINS_DIR . 'smarty_internal_templatebase.php';

    95 require_once SMARTY_SYSPLUGINS_DIR . 'smarty_internal_template.php';

    96 require_once SMARTY_SYSPLUGINS_DIR . 'smarty_resource.php';

    97 require_once SMARTY_SYSPLUGINS_DIR . 'smarty_variable.php';

    98 require_once SMARTY_SYSPLUGINS_DIR . 'smarty_template_source.php';

    99 

   100 /**

   101  * This is the main Smarty class

   102  *

   103  * @package Smarty

   104  */

   105 class Smarty extends Smarty_Internal_TemplateBase {

   106     /**#@+

   107      * constant definitions

   108      */

   109 

   110     /**

   111      * smarty version

   112      */

   113     const SMARTY_VERSION = '3.1.27';

   114 

   115     /**

   116      * define variable scopes

   117      */

   118     const SCOPE_LOCAL = 0;

   119 

   120     const SCOPE_PARENT = 1;

   121 

   122     const SCOPE_ROOT = 2;

   123 

   124     const SCOPE_GLOBAL = 3;

   125 

   126     /**

   127      * define caching modes

   128      */

   129     const CACHING_OFF = 0;

   130 

   131     const CACHING_LIFETIME_CURRENT = 1;

   132 

   133     const CACHING_LIFETIME_SAVED = 2;

   134 

   135     /**

   136      * define constant for clearing cache files be saved expiration datees

   137      */

   138     const CLEAR_EXPIRED = -1;

   139 

   140     /**

   141      * define compile check modes

   142      */

   143     const COMPILECHECK_OFF = 0;

   144 

   145     const COMPILECHECK_ON = 1;

   146 

   147     const COMPILECHECK_CACHEMISS = 2;

   148 

   149     /**

   150      * define debug modes

   151      */

   152     const DEBUG_OFF = 0;

   153 

   154     const DEBUG_ON = 1;

   155 

   156     const DEBUG_INDIVIDUAL = 2;

   157 

   158     /**

   159      * modes for handling of "<?php ... ?>" tags in templates.

   160      */

   161     const PHP_PASSTHRU = 0; //-> print tags as plain text

   162 

   163     const PHP_QUOTE = 1; //-> escape tags as entities

   164 

   165     const PHP_REMOVE = 2; //-> escape tags as entities

   166 

   167     const PHP_ALLOW = 3; //-> escape tags as entities

   168 

   169     /**

   170      * filter types

   171      */

   172     const FILTER_POST = 'post';

   173 

   174     const FILTER_PRE = 'pre';

   175 

   176     const FILTER_OUTPUT = 'output';

   177 

   178     const FILTER_VARIABLE = 'variable';

   179 

   180     /**

   181      * plugin types

   182      */

   183     const PLUGIN_FUNCTION = 'function';

   184 

   185     const PLUGIN_BLOCK = 'block';

   186 

   187     const PLUGIN_COMPILER = 'compiler';

   188 

   189     const PLUGIN_MODIFIER = 'modifier';

   190 

   191     const PLUGIN_MODIFIERCOMPILER = 'modifiercompiler';

   192 

   193     /**#@-*/

   194 

   195     /**

   196      * assigned global tpl vars

   197      */

   198     public static $global_tpl_vars = array();

   199 

   200     /**

   201      * error handler returned by set_error_hanlder() in Smarty::muteExpectedErrors()

   202      */

   203     public static $_previous_error_handler = null;

   204 

   205     /**

   206      * contains directories outside of SMARTY_DIR that are to be muted by muteExpectedErrors()

   207      */

   208     public static $_muted_directories = array('./templates_c/' => null, './cache/' => null);

   209 

   210     /**

   211      * Flag denoting if Multibyte String functions are available

   212      */

   213     public static $_MBSTRING = SMARTY_MBSTRING;

   214 

   215     /**

   216      * The character set to adhere to (e.g. "UTF-8")

   217      */

   218     public static $_CHARSET = SMARTY_RESOURCE_CHAR_SET;

   219 

   220     /**

   221      * The date format to be used internally

   222      * (accepts date() and strftime())

   223      */

   224     public static $_DATE_FORMAT = SMARTY_RESOURCE_DATE_FORMAT;

   225 

   226     /**

   227      * Flag denoting if PCRE should run in UTF-8 mode

   228      */

   229     public static $_UTF8_MODIFIER = 'u';

   230 

   231     /**

   232      * Flag denoting if operating system is windows

   233      */

   234     public static $_IS_WINDOWS = false;

   235 

   236     /**#@+

   237      * variables

   238      */

   239 

   240     /**

   241      * auto literal on delimiters with whitspace

   242      *

   243      * @var boolean

   244      */

   245     public $auto_literal = true;

   246 

   247     /**

   248      * display error on not assigned variables

   249      *

   250      * @var boolean

   251      */

   252     public $error_unassigned = false;

   253 

   254     /**

   255      * look up relative filepaths in include_path

   256      *

   257      * @var boolean

   258      */

   259     public $use_include_path = false;

   260 

   261     /**

   262      * template directory

   263      *

   264      * @var array

   265      */

   266     private $template_dir = array('./templates/');

   267 

   268     /**

   269      * joined template directory string used in cache keys

   270      *

   271      * @var string

   272      */

   273     public $joined_template_dir = './templates/';

   274 

   275     /**

   276      * joined config directory string used in cache keys

   277      *

   278      * @var string

   279      */

   280     public $joined_config_dir = './configs/';

   281 

   282     /**

   283      * default template handler

   284      *

   285      * @var callable

   286      */

   287     public $default_template_handler_func = null;

   288 

   289     /**

   290      * default config handler

   291      *

   292      * @var callable

   293      */

   294     public $default_config_handler_func = null;

   295 

   296     /**

   297      * default plugin handler

   298      *

   299      * @var callable

   300      */

   301     public $default_plugin_handler_func = null;

   302 

   303     /**

   304      * compile directory

   305      *

   306      * @var string

   307      */

   308     private $compile_dir = './templates_c/';

   309 

   310     /**

   311      * plugins directory

   312      *

   313      * @var array

   314      */

   315     private $plugins_dir = null;

   316 

   317     /**

   318      * cache directory

   319      *

   320      * @var string

   321      */

   322     private $cache_dir = './cache/';

   323 

   324     /**

   325      * config directory

   326      *

   327      * @var array

   328      */

   329     private $config_dir = array('./configs/');

   330 

   331     /**

   332      * force template compiling?

   333      *

   334      * @var boolean

   335      */

   336     public $force_compile = false;

   337 

   338     /**

   339      * check template for modifications?

   340      *

   341      * @var boolean

   342      */

   343     public $compile_check = true;

   344 

   345     /**

   346      * use sub dirs for compiled/cached files?

   347      *

   348      * @var boolean

   349      */

   350     public $use_sub_dirs = false;

   351 

   352     /**

   353      * allow ambiguous resources (that are made unique by the resource handler)

   354      *

   355      * @var boolean

   356      */

   357     public $allow_ambiguous_resources = false;

   358 

   359     /**

   360      * merge compiled includes

   361      *

   362      * @var boolean

   363      */

   364     public $merge_compiled_includes = false;

   365 

   366     /**

   367      * template inheritance merge compiled includes

   368      *

   369      * @var boolean

   370      */

   371     public $inheritance_merge_compiled_includes = true;

   372 

   373     /**

   374      * force cache file creation

   375      *

   376      * @var boolean

   377      */

   378     public $force_cache = false;

   379 

   380     /**

   381      * template left-delimiter

   382      *

   383      * @var string

   384      */

   385     public $left_delimiter = "{";

   386 

   387     /**

   388      * template right-delimiter

   389      *

   390      * @var string

   391      */

   392     public $right_delimiter = "}";

   393 

   394     /**#@+

   395      * security

   396      */

   397     /**

   398      * class name

   399      * This should be instance of Smarty_Security.

   400      *

   401      * @var string

   402      * @see Smarty_Security

   403      */

   404     public $security_class = 'Smarty_Security';

   405 

   406     /**

   407      * implementation of security class

   408      *

   409      * @var Smarty_Security

   410      */

   411     public $security_policy = null;

   412 

   413     /**

   414      * controls handling of PHP-blocks

   415      *

   416      * @var integer

   417      */

   418     public $php_handling = self::PHP_PASSTHRU;

   419 

   420     /**

   421      * controls if the php template file resource is allowed

   422      *

   423      * @var bool

   424      */

   425     public $allow_php_templates = false;

   426 

   427     /**

   428      * Should compiled-templates be prevented from being called directly?

   429      * {@internal

   430      * Currently used by Smarty_Internal_Template only.

   431      * }}

   432      *

   433      * @var boolean

   434      */

   435     public $direct_access_security = true;

   436 

   437     /**#@-*/

   438     /**

   439      * debug mode

   440      * Setting this to true enables the debug-console.

   441      *

   442      * @var boolean

   443      */

   444     public $debugging = false;

   445 

   446     /**

   447      * This determines if debugging is enable-able from the browser.

   448      * <ul>

   449      *  <li>NONE => no debugging control allowed</li>

   450      *  <li>URL => enable debugging when SMARTY_DEBUG is found in the URL.</li>

   451      * </ul>

   452      *

   453      * @var string

   454      */

   455     public $debugging_ctrl = 'NONE';

   456 

   457     /**

   458      * Name of debugging URL-param.

   459      * Only used when $debugging_ctrl is set to 'URL'.

   460      * The name of the URL-parameter that activates debugging.

   461      *

   462      * @var string

   463      */

   464     public $smarty_debug_id = 'SMARTY_DEBUG';

   465 

   466     /**

   467      * Path of debug template.

   468      *

   469      * @var string

   470      */

   471     public $debug_tpl = null;

   472 

   473     /**

   474      * When set, smarty uses this value as error_reporting-level.

   475      *

   476      * @var int

   477      */

   478     public $error_reporting = null;

   479 

   480     /**

   481      * Internal flag for getTags()

   482      *

   483      * @var boolean

   484      */

   485     public $get_used_tags = false;

   486 

   487     /**#@+

   488      * config var settings

   489      */

   490 

   491     /**

   492      * Controls whether variables with the same name overwrite each other.

   493      *

   494      * @var boolean

   495      */

   496     public $config_overwrite = true;

   497 

   498     /**

   499      * Controls whether config values of on/true/yes and off/false/no get converted to boolean.

   500      *

   501      * @var boolean

   502      */

   503     public $config_booleanize = true;

   504 

   505     /**

   506      * Controls whether hidden config sections/vars are read from the file.

   507      *

   508      * @var boolean

   509      */

   510     public $config_read_hidden = false;

   511 

   512     /**#@-*/

   513 

   514     /**#@+

   515      * resource locking

   516      */

   517 

   518     /**

   519      * locking concurrent compiles

   520      *

   521      * @var boolean

   522      */

   523     public $compile_locking = true;

   524 

   525     /**

   526      * Controls whether cache resources should emply locking mechanism

   527      *

   528      * @var boolean

   529      */

   530     public $cache_locking = false;

   531 

   532     /**

   533      * seconds to wait for acquiring a lock before ignoring the write lock

   534      *

   535      * @var float

   536      */

   537     public $locking_timeout = 10;

   538 

   539     /**#@-*/

   540 

   541     /**

   542      * resource type used if none given

   543      * Must be an valid key of $registered_resources.

   544      *

   545      * @var string

   546      */

   547     public $default_resource_type = 'file';

   548 

   549     /**

   550      * caching type

   551      * Must be an element of $cache_resource_types.

   552      *

   553      * @var string

   554      */

   555     public $caching_type = 'file';

   556 

   557     /**

   558      * internal config properties

   559      *

   560      * @var array

   561      */

   562     public $properties = array();

   563 

   564     /**

   565      * config type

   566      *

   567      * @var string

   568      */

   569     public $default_config_type = 'file';

   570 

   571     /**

   572      * cached template objects

   573      *

   574      * @var array

   575      */

   576     public $source_objects = array();

   577 

   578     /**

   579      * cached template objects

   580      *

   581      * @var array

   582      */

   583     public $template_objects = array();

   584 

   585     /**

   586      * enable resource caching

   587      *

   588      * @var bool

   589      */

   590     public $resource_caching = false;

   591 

   592     /**

   593      * enable template resource caching

   594      *

   595      * @var bool

   596      */

   597     public $template_resource_caching = true;

   598 

   599     /**

   600      * check If-Modified-Since headers

   601      *

   602      * @var boolean

   603      */

   604     public $cache_modified_check = false;

   605 

   606     /**

   607      * registered plugins

   608      *

   609      * @var array

   610      */

   611     public $registered_plugins = array();

   612 

   613     /**

   614      * plugin search order

   615      *

   616      * @var array

   617      */

   618     public $plugin_search_order = array('function', 'block', 'compiler', 'class');

   619 

   620     /**

   621      * registered objects

   622      *

   623      * @var array

   624      */

   625     public $registered_objects = array();

   626 

   627     /**

   628      * registered classes

   629      *

   630      * @var array

   631      */

   632     public $registered_classes = array();

   633 

   634     /**

   635      * registered filters

   636      *

   637      * @var array

   638      */

   639     public $registered_filters = array();

   640 

   641     /**

   642      * registered resources

   643      *

   644      * @var array

   645      */

   646     public $registered_resources = array();

   647 

   648     /**

   649      * resource handler cache

   650      *

   651      * @var array

   652      */

   653     public $_resource_handlers = array();

   654 

   655     /**

   656      * registered cache resources

   657      *

   658      * @var array

   659      */

   660     public $registered_cache_resources = array();

   661 

   662     /**

   663      * cache resource handler cache

   664      *

   665      * @var array

   666      */

   667     public $_cacheresource_handlers = array();

   668 

   669     /**

   670      * autoload filter

   671      *

   672      * @var array

   673      */

   674     public $autoload_filters = array();

   675 

   676     /**

   677      * default modifier

   678      *

   679      * @var array

   680      */

   681     public $default_modifiers = array();

   682 

   683     /**

   684      * autoescape variable output

   685      *

   686      * @var boolean

   687      */

   688     public $escape_html = false;

   689 

   690     /**

   691      * global internal smarty vars

   692      *

   693      * @var array

   694      */

   695     public static $_smarty_vars = array();

   696 

   697     /**

   698      * start time for execution time calculation

   699      *

   700      * @var int

   701      */

   702     public $start_time = 0;

   703 

   704     /**

   705      * default file permissions

   706      *

   707      * @var int

   708      */

   709     public $_file_perms = 0644;

   710 

   711     /**

   712      * default dir permissions

   713      *

   714      * @var int

   715      */

   716     public $_dir_perms = 0771;

   717 

   718     /**

   719      * block tag hierarchy

   720      *

   721      * @var array

   722      */

   723     public $_tag_stack = array();

   724 

   725     /**

   726      * required by the compiler for BC

   727      *

   728      * @var string

   729      */

   730     public $_current_file = null;

   731 

   732     /**

   733      * internal flag to enable parser debugging

   734      *

   735      * @var bool

   736      */

   737     public $_parserdebug = false;

   738 

   739     /**

   740      * Cache of is_file results of loadPlugin()

   741      *

   742      * @var array

   743      */

   744     public $_is_file_cache = array();

   745 

   746     /**#@-*/

   747 

   748     /**

   749      * Initialize new Smarty object

   750      */

   751     public function __construct() {

   752         if (is_callable('mb_internal_encoding')) {

   753             mb_internal_encoding(Smarty::$_CHARSET);

   754         }

   755         $this->start_time = microtime(true);

   756         // check default dirs for overloading

   757         if ($this->template_dir[0] !== './templates/' || isset($this->template_dir[1])) {

   758             $this->setTemplateDir($this->template_dir);

   759         }

   760         if ($this->config_dir[0] !== './configs/' || isset($this->config_dir[1])) {

   761             $this->setConfigDir($this->config_dir);

   762         }

   763         if ($this->compile_dir !== './templates_c/') {

   764             unset(self::$_muted_directories['./templates_c/']);

   765             $this->setCompileDir($this->compile_dir);

   766         }

   767         if ($this->cache_dir !== './cache/') {

   768             unset(self::$_muted_directories['./cache/']);

   769             $this->setCacheDir($this->cache_dir);

   770         }

   771         if (isset($this->plugins_dir)) {

   772             $this->setPluginsDir($this->plugins_dir);

   773         } else {

   774             $this->setPluginsDir(SMARTY_PLUGINS_DIR);

   775         }

   776         if (isset($_SERVER['SCRIPT_NAME'])) {

   777             Smarty::$global_tpl_vars['SCRIPT_NAME'] = new Smarty_Variable($_SERVER['SCRIPT_NAME']);

   778         }

   779 

   780         // Check if we're running on windows

   781         Smarty::$_IS_WINDOWS = strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';

   782 

   783         // let PCRE (preg_*) treat strings as ISO-8859-1 if we're not dealing with UTF-8

   784         if (Smarty::$_CHARSET !== 'UTF-8') {

   785             Smarty::$_UTF8_MODIFIER = '';

   786         }

   787     }

   788 

   789     /**

   790      * fetches a rendered Smarty template

   791      *

   792      * @param  string $template the resource handle of the template file or template object

   793      * @param  mixed $cache_id cache id to be used with this template

   794      * @param  mixed $compile_id compile id to be used with this template

   795      * @param  object $parent next higher level of Smarty variables

   796      * @param  bool $display true: display, false: fetch

   797      * @param  bool $merge_tpl_vars not used - left for BC

   798      * @param  bool $no_output_filter not used - left for BC

   799      *

   800      * @throws Exception

   801      * @throws SmartyException

   802      * @return string rendered template output

   803      */

   804     public function fetch($template = null, $cache_id = null, $compile_id = null, $parent = null, $display = false, $merge_tpl_vars = true, $no_output_filter = false) {

   805         if ($cache_id !== null && is_object($cache_id)) {

   806             $parent = $cache_id;

   807             $cache_id = null;

   808         }

   809         if ($parent === null) {

   810             $parent = $this;

   811         }

   812         // get template object

   813         $_template = is_object($template) ? $template : $this->createTemplate($template, $cache_id, $compile_id, $parent, false);

   814         // set caching in template object

   815         $_template->caching = $this->caching;

   816         // fetch template content

   817         return $_template->render(true, false, $display);

   818     }

   819 

   820     /**

   821      * displays a Smarty template

   822      *

   823      * @param string $template the resource handle of the template file or template object

   824      * @param mixed $cache_id cache id to be used with this template

   825      * @param mixed $compile_id compile id to be used with this template

   826      * @param object $parent next higher level of Smarty variables

   827      */

   828     public function display($template = null, $cache_id = null, $compile_id = null, $parent = null) {

   829         // display template

   830         $this->fetch($template, $cache_id, $compile_id, $parent, true);

   831     }

   832 

   833     /**

   834      * Check if a template resource exists

   835      *

   836      * @param  string $resource_name template name

   837      *

   838      * @return boolean status

   839      */

   840     public function templateExists($resource_name) {

   841         // create template object

   842         $save = $this->template_objects;

   843         $tpl = new $this->template_class($resource_name, $this);

   844         // check if it does exists

   845         $result = $tpl->source->exists;

   846         $this->template_objects = $save;

   847 

   848         return $result;

   849     }

   850 

   851     /**

   852      * Returns a single or all global  variables

   853      *

   854      * @param  string $varname variable name or null

   855      *

   856      * @return string variable value or or array of variables

   857      */

   858     public function getGlobal($varname = null) {

   859         if (isset($varname)) {

   860             if (isset(self::$global_tpl_vars[$varname])) {

   861                 return self::$global_tpl_vars[$varname]->value;

   862             } else {

   863                 return '';

   864             }

   865         } else {

   866             $_result = array();

   867             foreach (self::$global_tpl_vars AS $key => $var) {

   868                 $_result[$key] = $var->value;

   869             }

   870 

   871             return $_result;

   872         }

   873     }

   874 

   875     /**

   876      * Empty cache folder

   877      *

   878      * @param  integer $exp_time expiration time

   879      * @param  string $type resource type

   880      *

   881      * @return integer number of cache files deleted

   882      */

   883     public function clearAllCache($exp_time = null, $type = null) {

   884         // load cache resource and call clearAll

   885         $_cache_resource = Smarty_CacheResource::load($this, $type);

   886         Smarty_CacheResource::invalidLoadedCache($this);

   887 

   888         return $_cache_resource->clearAll($this, $exp_time);

   889     }

   890 

   891     /**

   892      * Empty cache for a specific template

   893      *

   894      * @param  string $template_name template name

   895      * @param  string $cache_id cache id

   896      * @param  string $compile_id compile id

   897      * @param  integer $exp_time expiration time

   898      * @param  string $type resource type

   899      *

   900      * @return integer number of cache files deleted

   901      */

   902     public function clearCache($template_name, $cache_id = null, $compile_id = null, $exp_time = null, $type = null) {

   903         // load cache resource and call clear

   904         $_cache_resource = Smarty_CacheResource::load($this, $type);

   905         Smarty_CacheResource::invalidLoadedCache($this);

   906 

   907         return $_cache_resource->clear($this, $template_name, $cache_id, $compile_id, $exp_time);

   908     }

   909 

   910     /**

   911      * Loads security class and enables security

   912      *

   913      * @param  string|Smarty_Security $security_class if a string is used, it must be class-name

   914      *

   915      * @return Smarty                 current Smarty instance for chaining

   916      * @throws SmartyException        when an invalid class name is provided

   917      */

   918     public function enableSecurity($security_class = null) {

   919         if ($security_class instanceof Smarty_Security) {

   920             $this->security_policy = $security_class;

   921 

   922             return $this;

   923         } elseif (is_object($security_class)) {

   924             throw new SmartyException("Class '" . get_class($security_class) . "' must extend Smarty_Security.");

   925         }

   926         if ($security_class == null) {

   927             $security_class = $this->security_class;

   928         }

   929         if (!class_exists($security_class)) {

   930             throw new SmartyException("Security class '$security_class' is not defined");

   931         } elseif ($security_class !== 'Smarty_Security' && !is_subclass_of($security_class, 'Smarty_Security')) {

   932             throw new SmartyException("Class '$security_class' must extend Smarty_Security.");

   933         } else {

   934             $this->security_policy = new $security_class($this);

   935         }

   936 

   937         return $this;

   938     }

   939 

   940     /**

   941      * Disable security

   942      *

   943      * @return Smarty current Smarty instance for chaining

   944      */

   945     public function disableSecurity() {

   946         $this->security_policy = null;

   947 

   948         return $this;

   949     }

   950 

   951     /**

   952      * Set template directory

   953      *

   954      * @param  string|array $template_dir directory(s) of template sources

   955      *

   956      * @return Smarty       current Smarty instance for chaining

   957      */

   958     public function setTemplateDir($template_dir) {

   959         $this->template_dir = array();

   960         foreach ((array)$template_dir as $k => $v) {

   961             $this->template_dir[$k] = rtrim($v, '/\\') . DS;

   962         }

   963         $this->joined_template_dir = join(' # ', $this->template_dir);

   964         return $this;

   965     }

   966 

   967     /**

   968      * Add template directory(s)

   969      *

   970      * @param  string|array $template_dir directory(s) of template sources

   971      * @param  string $key of the array element to assign the template dir to

   972      *

   973      * @return Smarty          current Smarty instance for chaining

   974      * @throws SmartyException when the given template directory is not valid

   975      */

   976     public function addTemplateDir($template_dir, $key = null) {

   977         $this->_addDir('template_dir', $template_dir, $key);

   978         $this->joined_template_dir = join(' # ', $this->template_dir);

   979         return $this;

   980     }

   981 

   982     /**

   983      * Get template directories

   984      *

   985      * @param mixed $index index of directory to get, null to get all

   986      *

   987      * @return array|string list of template directories, or directory of $index

   988      */

   989     public function getTemplateDir($index = null) {

   990         if ($index !== null) {

   991             return isset($this->template_dir[$index]) ? $this->template_dir[$index] : null;

   992         }

   993         return (array)$this->template_dir;

   994     }

   995 

   996     /**

   997      * Set config directory

   998      *

   999      * @param $config_dir

  1000      *

  1001      * @return Smarty       current Smarty instance for chaining

  1002      */

  1003     public function setConfigDir($config_dir) {

  1004         $this->config_dir = array();

  1005         foreach ((array)$config_dir as $k => $v) {

  1006             $this->config_dir[$k] = rtrim($v, '/\\') . DS;

  1007         }

  1008         $this->joined_config_dir = join(' # ', $this->config_dir);

  1009         return $this;

  1010     }

  1011 

  1012     /**

  1013      * Add config directory(s)

  1014      *

  1015      * @param string|array $config_dir directory(s) of config sources

  1016      * @param mixed $key key of the array element to assign the config dir to

  1017      *

  1018      * @return Smarty current Smarty instance for chaining

  1019      */

  1020     public function addConfigDir($config_dir, $key = null) {

  1021         $this->_addDir('config_dir', $config_dir, $key);

  1022         $this->joined_config_dir = join(' # ', $this->config_dir);

  1023         return $this;

  1024     }

  1025 

  1026     /**

  1027      * Get config directory

  1028      *

  1029      * @param mixed $index index of directory to get, null to get all

  1030      *

  1031      * @return array|string configuration directory

  1032      */

  1033     public function getConfigDir($index = null) {

  1034         if ($index !== null) {

  1035             return isset($this->config_dir[$index]) ? $this->config_dir[$index] : null;

  1036         }

  1037         return (array)$this->config_dir;

  1038     }

  1039 

  1040     /**

  1041      * Set plugins directory

  1042      *

  1043      * @param  string|array $plugins_dir directory(s) of plugins

  1044      *

  1045      * @return Smarty       current Smarty instance for chaining

  1046      */

  1047     public function setPluginsDir($plugins_dir) {

  1048         $this->plugins_dir = array();

  1049         $this->addPluginsDir($plugins_dir);

  1050         return $this;

  1051     }

  1052 

  1053     /**

  1054      * Adds directory of plugin files

  1055      *

  1056      * @param $plugins_dir

  1057      *

  1058      * @return Smarty current Smarty instance for chaining

  1059      */

  1060     public function addPluginsDir($plugins_dir) {

  1061         // make sure we're dealing with an array

  1062         $this->plugins_dir = (array)$this->plugins_dir;

  1063         foreach ((array)$plugins_dir as $v) {

  1064             $this->plugins_dir[] = rtrim($v, '/\\') . DS;

  1065         }

  1066         $this->plugins_dir = array_unique($this->plugins_dir);

  1067         $this->_is_file_cache = array();

  1068         return $this;

  1069     }

  1070 

  1071     /**

  1072      * Get plugin directories

  1073      *

  1074      * @return array list of plugin directories

  1075      */

  1076     public function getPluginsDir() {

  1077         return (array)$this->plugins_dir;

  1078     }

  1079 

  1080     /**

  1081      * Set compile directory

  1082      *

  1083      * @param  string $compile_dir directory to store compiled templates in

  1084      *

  1085      * @return Smarty current Smarty instance for chaining

  1086      */

  1087     public function setCompileDir($compile_dir) {

  1088         $this->compile_dir = rtrim($compile_dir, '/\\') . DS;

  1089         if (!isset(Smarty::$_muted_directories[$this->compile_dir])) {

  1090             Smarty::$_muted_directories[$this->compile_dir] = null;

  1091         }

  1092 

  1093         return $this;

  1094     }

  1095 

  1096     /**

  1097      * Get compiled directory

  1098      *

  1099      * @return string path to compiled templates

  1100      */

  1101     public function getCompileDir() {

  1102         return $this->compile_dir;

  1103     }

  1104 

  1105     /**

  1106      * Set cache directory

  1107      *

  1108      * @param  string $cache_dir directory to store cached templates in

  1109      *

  1110      * @return Smarty current Smarty instance for chaining

  1111      */

  1112     public function setCacheDir($cache_dir) {

  1113         $this->cache_dir = rtrim($cache_dir, '/\\') . DS;

  1114         if (!isset(Smarty::$_muted_directories[$this->cache_dir])) {

  1115             Smarty::$_muted_directories[$this->cache_dir] = null;

  1116         }

  1117         return $this;

  1118     }

  1119 

  1120     /**

  1121      * Get cache directory

  1122      *

  1123      * @return string path of cache directory

  1124      */

  1125     public function getCacheDir() {

  1126         return $this->cache_dir;

  1127     }

  1128 

  1129     /**

  1130      * add directories to given property name

  1131      *

  1132      * @param string $dirName directory property name

  1133      * @param string|array $dir directory string or array of strings

  1134      * @param mixed $key optional key

  1135      */