Хранилища Subversion ant

<?php

/**

* Smarty Internal Plugin Template

*

* This files contains the Smarty template engine

*

* @package Smarty

* @subpackage Templates

* @author Uwe Tews

*/

/**

* Main class with template data structures and methods

*/

class Smarty_Internal_Template extends Smarty_Internal_TemplateBase {

    // object cache

    public $compiler_object = null;

    public $cacher_object = null;

    // Smarty parameter

    public $cache_id = null;

    public $compile_id = null;

    public $caching = null;

    public $cache_lifetime = null;

    public $cacher_class = null;

    public $caching_type = null;

    public $force_compile = null;

    // Template resource

    public $template_resource = null;

    public $resource_type = null;

    public $resource_name = null;

    private $usesCompiler = null;

    private $isEvaluated = null;

    private $isExisting = null;

    // Template source

    public $template_filepath = null;

    public $template_source = null;

    private $template_timestamp = null;

    // Compiled template

    private $compiled_filepath = null;

    public $compiled_template = null;

    private $compiled_timestamp = null;

    public $compile_time = 0;

    public $mustCompile = null;

    public $suppressHeader = false;

    public $extract_code = false;

    public $extracted_compiled_code = '';

    // Rendered content

    public $rendered_content = null;

    // Cache file

    private $cached_filepath = null;

    private $cached_timestamp = null;

    private $isCached = null;

    public $cache_time = 0;

    // template variables

    public $tpl_vars = array();

    public $parent = null;

    public $config_vars = array();

    // storage for plugin

    public $plugin_data = array();

    // special properties

    public $properties = array();

    // storage for block data

    public $block_data = array();

    public $render_time = 0;

    /**

    * Create template data object

    *

    * Some of the global Smarty settings copied to template scope

    * It load the required template resources and cacher plugins

    *

    * @param string $template_resource template resource string

    * @param object $_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

    */

    public function __construct($template_resource, $smarty, $_parent = null, $_cache_id = null, $_compile_id = null)

    {

        $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->force_compile = $this->smarty->force_compile;

        $this->caching = $this->smarty->caching;

        $this->cache_lifetime = $this->smarty->cache_lifetime;

        $this->force_cache = $this->smarty->force_cache;

        $this->cacher_class = $this->smarty->cacher_class;

        $this->caching_type = $this->smarty->default_caching_type;

        $this->security = $this->smarty->security;

        $this->cache_resource_class = 'Smarty_Internal_CacheResource_' . ucfirst($this->caching_type);

        $this->parent = $_parent;

        $this->properties['file_dependency'] = array();

        // dummy local smarty variable

        $this->tpl_vars['smarty'] = new Smarty_Variable;

        // Template resource

        $this->template_resource = $template_resource;

        // parse resource name

        if (!$this->parseResourceName ($template_resource, $this->resource_type, $this->resource_name, $dummy)) {

            throw new Exception ("Unable to parse resource name \"{$template_resource}\"");

        }

        // load cache resource

        if (!$this->isEvaluated() && $this->caching && !isset($this->smarty->cache_resource_objects[$this->caching_type])) {

            $this->smarty->loadPlugin($this->cache_resource_class);

            $this->smarty->cache_resource_objects[$this->caching_type] = new $this->cache_resource_class($this->smarty);

        }

    }

    /**

    * Returns the template filepath

    *

    * The template filepath is determined by the actual resource handler

    *

    * @return string the template filepath

    */

    public function getTemplateFilepath ()

    {

        return $this->template_filepath === null ?

        $this->template_filepath = $this->smarty->resource_objects[$this->resource_type]->getTemplateFilepath($this) :

        $this->template_filepath;

    }

    /**

    * Returns the timpestamp of the template source

    *

    * The template timestamp is determined by the actual resource handler

    *

    * @return integer the template timestamp

    */

    public function getTemplateTimestamp ()

    {

        return $this->template_timestamp === null ?

        $this->template_timestamp = $this->smarty->resource_objects[$this->resource_type]->getTemplateTimestamp($this) :

        $this->template_timestamp;

    }

    /**

    * Returns the template source code

    *

    * The template source is being read by the actual resource handler

    *

    * @return string the template source

    */

    public function getTemplateSource ()

    {

        if ($this->template_source === null) {

            if (!$this->smarty->resource_objects[$this->resource_type]->getTemplateSource($this)) {

                throw new Exception("Unable to read template '{$this->resource_name}'");

            }

        }

        return $this->template_source;

    }

    /**

    * Returns if the  template is existing

    *

    * The status is determined by the actual resource handler

    *

    * @return boolean true if the template exists

    */

    public function isExisting ($error= false)

    {

        if ($this->isExisting === null) {

        $this->isExisting = $this->smarty->resource_objects[$this->resource_type]->isExisting($this);

        }

        if (!$this->isExisting && $error) {

            throw new Exception("Unable to load template \"{$this->resource_type} : {$this->resource_name}\"");

        }

        return $this->isExisting;

    }

    /**

    * Returns if the template resource uses the Smarty compiler

    *

    * The status is determined by the actual resource handler

    *

    * @return boolean true if the template will use the compiler

    */

    public function usesCompiler ()

    {

        return $this->usesCompiler === null ?

        $this->usesCompiler = $this->smarty->resource_objects[$this->resource_type]->usesCompiler() :

        $this->usesCompiler;

    }

    /**

    * Returns if the compiled template is stored or just evaluated in memory

    *

    * The status is determined by the actual resource handler

    *

    * @return boolean true if the compiled template has to be evaluated

    */

    public function isEvaluated ()

    {

        return $this->isEvaluated === null ?

        $this->isEvaluated = $this->smarty->resource_objects[$this->resource_type]->isEvaluated() :

        $this->isEvaluated;

    }

    /**

    * 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 boolean true if the template must be compiled

    */

    public function mustCompile ()

    {

        $this->isExisting(true);

        if ($this->mustCompile === null) {

            $this->mustCompile = ($this->usesCompiler() && ($this->force_compile || $this->isEvaluated() || ($this->smarty->compile_check && $this->getCompiledTimestamp () !== $this->getTemplateTimestamp ())));

        }

        return $this->mustCompile;

    }

    /**

    * Returns the compiled template filepath

    *

    * @return string the template filepath

    */

    public function getCompiledFilepath ()

    {

        return $this->compiled_filepath === null ?

        ($this->compiled_filepath = !$this->isEvaluated() ? $this->smarty->resource_objects[$this->resource_type]->getCompiledFilepath($this) : false) :

        $this->compiled_filepath;

    }

    /**

    * Returns the timpestamp of the compiled template

    *

    * @return integer the template timestamp

    */

    public function getCompiledTimestamp ()

    {

        return $this->compiled_timestamp === null ?

        ($this->compiled_timestamp = (!$this->isEvaluated() && file_exists($this->getCompiledFilepath())) ? filemtime($this->getCompiledFilepath()) : false) :

        $this->compiled_timestamp;

    }

    /**

    * Returns the compiled template

    *

    * It checks if the template must be compiled or just read from the template resource

    *

    * @return string the compiled template

    */

    public function getCompiledTemplate ()

    {

        if ($this->compiled_template === null) {

            // see if template needs compiling.

            if ($this->mustCompile()) {

                $this->compileTemplateSource();

            } else {

                if ($this->compiled_template === null) {

                    $this->compiled_template = !$this->isEvaluated() && $this->usesCompiler() ? file_get_contents($this->getCompiledFilepath()) : false;

                }

            }

        }

        return $this->compiled_template;

    }

    /**

    * Compiles the template

    *

    * If the template is not evaluated the compiled template is saved on disk

    */

    public function compileTemplateSource ()

    {

        $_start_time = $this->_get_time();

        if (!$this->isEvaluated) {

            $this->properties['file_dependency']['F' . abs(crc32($this->getTemplateFilepath()))] = array($this->getTemplateFilepath(), $this->getTemplateTimestamp());

        }

        // compile template

        if (!is_object($this->compiler_object)) {

            // load compiler

            require_once(SMARTY_SYSPLUGINS_DIR . 'internal.compilebase.php');

            require_once(SMARTY_SYSPLUGINS_DIR . 'internal.templatecompilerbase.php');

            // $this->smarty->loadPlugin('Smarty_Internal_CompileBase');

            // $this->smarty->loadPlugin('Smarty_Internal_TemplateCompilerBase');

            $this->smarty->loadPlugin($this->smarty->resource_objects[$this->resource_type]->compiler_class);

            $this->compiler_object = new $this->smarty->resource_objects[$this->resource_type]->compiler_class($this->smarty->resource_objects[$this->resource_type]->template_lexer_class, $this->smarty->resource_objects[$this->resource_type]->template_parser_class, $this->smarty);

            // load cacher

            if ($this->caching) {

                $this->smarty->loadPlugin($this->cacher_class);

                $this->cacher_object = new $this->cacher_class($this->smarty);

            }

        }

        if (!is_object($this->smarty->write_file_object)) {

            require_once(SMARTY_SYSPLUGINS_DIR . 'internal.write_file.php');

            // $this->smarty->loadPlugin("Smarty_Internal_Write_File");

            $this->smarty->write_file_object = new Smarty_Internal_Write_File;

        }

        // call compiler

        if ($this->compiler_object->compileTemplate($this)) {

            // compiling succeded

            if (!$this->isEvaluated()) {

                // write compiled template

                $this->smarty->write_file_object->writeFile($this->getCompiledFilepath(), $this->compiled_template);

                // make template and compiled file timestamp match

                touch($this->getCompiledFilepath(), $this->getTemplateTimestamp());

            }

        } else {

            // error compiling template

            throw new Exception("Error compiling template {$this->getTemplateFilepath ()}");

            return false;

        }

        $this->compile_time += $this->_get_time() - $_start_time;

    }

    /**

    * Returns the filepath of the cached template output

    *

    * The filepath is determined by the actual resource handler of the cacher

    *

    * @return string the cache filepath

    */

    public function getCachedFilepath ()

    {

        return $this->cached_filepath === null ?

        $this->cached_filepath = ($this->isEvaluated() || !$this->caching) ? false : $this->smarty->cache_resource_objects[$this->caching_type]->getCachedFilepath($this) :

        $this->cached_filepath;

    }

    /**

    * Returns the timpestamp of the cached template output

    *

    * The timestamp is determined by the actual resource handler of the cacher

    *

    * @return integer the template timestamp

    */

    public function getCachedTimestamp ()

    {

        return $this->cached_timestamp === null ?

        $this->cached_timestamp = ($this->isEvaluated() || !$this->caching) ? false : $this->smarty->cache_resource_objects[$this->caching_type]->getCachedTimestamp($this) :

        $this->cached_timestamp;

    }

    /**

    * Returns the cached template output

    *

    * @return string |booelan the template content or false if the file does not exist

    */

    public function getCachedContent ()

    {

        return $this->rendered_content === null ?

        $this->rendered_content = ($this->isEvaluated() || !$this->caching) ? false : $this->smarty->cache_resource_objects[$this->caching_type]->getCachedContents($this) :

        $this->rendered_content;

    }

    /**

    * Writes the cached template output

    */

    public function writeCachedContent ()

    {

        // build file dependency string

        $this->properties['cache_lifetime'] = $this->cache_lifetime;

        return ($this->isEvaluated() || !$this->caching) ? false : $this->smarty->cache_resource_objects[$this->caching_type]->writeCachedContent($this, $this->createPropertyHeader() . $this->rendered_content);

    }

    /**

    * Checks of a valid version redered HTML output is in the cache

    *

    * If the cache is valid the contents is stored in the template object

    *

    * @return boolean true if cache is valid

    */

    public function isCached ()

    {

        if ($this->isCached === null) {

            $this->isCached = false;

            if ($this->caching && !$this->isEvaluated() && !$this->force_compile && !$this->force_cache) {

                if ($this->getCachedTimestamp() === false) {

                    return $this->isCached;

                }

                if (($this->caching == SMARTY_CACHING_LIVETIME_SAVED || ($this->caching == SMARTY_CACHING_LIFETIME_CURRENT && (time() <= ($this->getCachedTimestamp() + $this->cache_lifetime) || $this->cache_lifetime < 0)))) {

                    $_start_time = $this->_get_time();

                    $this->rendered_content = $this->smarty->cache_resource_objects[$this->caching_type]->getCachedContents($this);

                    $this->cache_time += $this->_get_time() - $_start_time;

                    if ($this->caching == SMARTY_CACHING_LIVETIME_SAVED && (time() > ($this->getCachedTimestamp() + $this->properties['cache_lifetime']) || $this->properties['cache_lifetime'] < 0)) {

                        $this->rendered_content = null;

                        return $this->isCached;

                    }

                    if (!empty($this->properties['file_dependency']) && $this->smarty->compile_check) {

                        foreach ($this->properties['file_dependency'] as $_file_to_check) {

                            If (is_file($_file_to_check[0])) {

                                $mtime = filemtime($_file_to_check[0]);

                            } else {

                                $this->parseResourceName($_file_to_check[0], $resource_type, $resource_name, $resource_handler);

                                $mtime = $resource_handler->getTemplateTimestampTypeName($resource_type, $resource_name);

                            }

                            // If ($mtime > $this->getCachedTimestamp()) {

                            If ($mtime > $_file_to_check[1]) {

                                $this->rendered_content = null;

                                $this->properties['file_dependency'] = array();

                                return $this->isCached;

                            }

                        }

                    }

                    $this->isCached = true;

                }

            }

        }

        return $this->isCached;

    }

    /**

    * Render the output using the compiled template or the PHP template source

    *

    * The rendering process is accomplished by just including the PHP files.

    * The only exceptions are evaluated templates (string template). Their code has

    * to be evaluated

    */

    public function renderTemplate ()

    {

        if ($this->usesCompiler()) {

            if ($this->mustCompile()) {

                $this->compileTemplateSource();

            }

            $_smarty_tpl = $this;

            $_start_time = $this->_get_time();

            ob_start();

            if ($this->isEvaluated()) {

                eval("?>" . $this->compiled_template);

            } else {

                include($this->getCompiledFilepath ());

                // check file dependencies at compiled code

                if ($this->smarty->compile_check) {

                    if (!empty($this->properties['file_dependency'])) {

                        $this->mustCompile = false;

                        foreach ($this->properties['file_dependency'] as $_file_to_check) {

                            If (is_file($_file_to_check[0])) {

                                $mtime = filemtime($_file_to_check[0]);

                            } else {

                                $this->parseResourceName($_file_to_check[0], $resource_type, $resource_name, $resource_handler);

                                $mtime = $resource_handler->getTemplateTimestampTypeName($resource_type, $resource_name);

                            }

                            If ($mtime != $_file_to_check[1]) {

                                $this->properties['file_dependency'] = array();

                                $this->mustCompile = true;

                            }

                        }

                        if ($this->mustCompile) {

                            // recompile and render again

                            ob_get_clean();

                            $this->compileTemplateSource();

                            ob_start();

                            include($this->getCompiledFilepath ());

                        }

                    }

                }

            }

        } else {

            if (is_callable(array($this->smarty->resource_objects[$this->resource_type], 'renderUncompiled'))) {

                $_start_time = $this->_get_time();

                ob_start();

                $this->smarty->resource_objects[$this->resource_type]->renderUncompiled($this);

            } else {

                throw new Exception("Resource '$this->resource_type' must have 'renderUncompiled' methode");

            }

        }

        $this->rendered_content = ob_get_clean();

        $this->render_time += $this->_get_time() - $_start_time;

        if (!$this->isEvaluated) {

            $this->properties['file_dependency']['F' . abs(crc32($this->getTemplateFilepath()))] = array($this->getTemplateFilepath(), $this->getTemplateTimestamp());

        }

        if ($this->parent instanceof Smarty_Template or $this->parent instanceof Smarty_Internal_Template) {

            // var_dump('merge ', $this->parent->getTemplateFilepath(), $this->parent->properties['file_dependency'], $this->getTemplateFilepath(), $this->properties['file_dependency']);

            $this->parent->properties['file_dependency'] = array_merge($this->parent->properties['file_dependency'], $this->properties['file_dependency']);

        }

        // write to cache when nessecary

        if (!$this->isEvaluated() && $this->caching) {

            // write rendered template

            $this->writeCachedContent($this);

            // cache file may contain nocache code. read it back for processing

            $this->rendered_content = $this->smarty->cache_resource_objects[$this->caching_type]->getCachedContents($this);

        }

    }

    /**

    * Returns the rendered HTML output

    *

    * If the cache is valid the cached content is used, otherwise

    * the output is rendered from the compiled template or PHP template source

    *

    * @return string rendered HTML output

    */

    public function getRenderedTemplate ()

    {

        // disable caching for evaluated code

        if ($this->isEvaluated()) {

            $this->caching = false;

        }

        // checks if template exists

        $this->isExisting(true);

        // read from cache or render

        if ($this->rendered_content === null && !$this->isCached()) {

            // render template (not loaded and not in cache)

            $this->renderTemplate();

        }

        $this->updateParentVariables();

        return (isset($this->smarty->autoload_filters['output']) || isset($this->smarty->registered_filters['output']))?

        $this->smarty->filter_handler->execute('output', $this->rendered_content) : $this->rendered_content;

    }

    /**

    * parse a template resource in its name and type

    *

    * @param string $template_resource template resource specification

    */

    public function parseResourceName($template_resource, &$resource_type, &$resource_name, &$resource_handler)

    {

        if (empty($template_resource))

            return false;

        if (strpos($template_resource, ':') === false) {

            // no resource given, use default

            $resource_type = $this->smarty->default_resource_type;

            $resource_name = $template_resource;

        } else {

            // get type and name from path

            list($resource_type, $resource_name) = explode(':', $template_resource, 2);

            if (strlen($resource_type) == 1) {

                // 1 char is not resource type, but part of filepath

                $resource_type = 'file';

                $resource_name = $template_resource;

            } else {

                $resource_type = strtolower($resource_type);

            }

        }

        // load resource handler if required

        if (!isset($this->smarty->resource_objects[$resource_type])) {

            // try registered resource

            if (isset($this->smarty->_plugins['resource'][$resource_type])) {

                require_once(SMARTY_SYSPLUGINS_DIR . 'internal.resource_registered.php');

                // $this->smarty->loadPlugin('Smarty_Internal_Resource_Registered');

                $resource_handler = $this->smarty->resource_objects[$resource_type] = new Smarty_Internal_Resource_Registered($this->smarty);

            } else {

                // try sysplugins dir

                $_resource_class = "Smarty_Internal_Resource_{$resource_type}";

                if ($this->smarty->loadPlugin($_resource_class)) {

                    $resource_handler = $this->smarty->resource_objects[$resource_type] = new $_resource_class($this->smarty);

                } else {

                    // try plugins dir

                    $_resource_class = "Smarty_Resource_{$resource_type}";

                    if ($this->smarty->loadPlugin($_resource_class)) {

                        $resource_handler = $this->smarty->resource_objects[$resource_type] = new $_resource_class($this->smarty);

                    } else {

                        // try streams

                        $_known_stream = stream_get_wrappers();

                        if (in_array($resource_type, $_known_stream)) {

                            // is known stream

                            if ($this->smarty->security) {

                                $this->smarty->security_handler->isTrustedStream($resource_type);

                            }

                            require_once(SMARTY_SYSPLUGINS_DIR . 'internal.resource_stream.php');

                            // $this->smarty->loadPlugin('Smarty_Internal_Resource_Stream');

                            $resource_handler = $this->smarty->resource_objects[$resource_type] = new Smarty_Internal_Resource_Stream($this->smarty);

//                            $resource_name = str_replace(':', '://', $template_resource);

                        } else {

                            throw new Exception('Unkown resource type \'' . $resource_type . '\'');

                        }

                    }

                }

            }

        } else {

            $resource_handler = $this->smarty->resource_objects[$resource_type];

        }

        // cache template object under a unique ID

        // do not cache string resources

        if ($resource_type != 'string') {

           $this->smarty->template_objects[$this->buildTemplateId ($this->template_resource, $this->cache_id, $this->compile_id)] = $this;

        }

        return true;

    }

    /**

    * get system filepath to template

    */

    public function buildTemplateFilepath ($file = null)

    {

        if ($file == null) {

            $file = $this->resource_name;

        }

        foreach((array)$this->smarty->template_dir as $_template_dir) {

            if (strpos('/\\', substr($_template_dir, -1)) === false) {

                $_template_dir .= DS;

            }

            $_filepath = $_template_dir . $file;

            if (file_exists($_filepath))

                return $_filepath;

        }

        if (file_exists($file)) return $file;

        // no tpl file found

        if (!empty($this->smarty->default_template_handler_func)) {

            if (!is_callable($this->smarty->default_template_handler_func)) {

                throw new Exception("Default template handler not callable");

            } else {

                $_return = call_user_func_array($this->smarty->default_template_handler_func,

                    array($this->resource_type, $this->resource_name, &$this->template_source, &$this->template_timestamp, &$this));

                if ($_return == true) {

                    return $_filepath;

                }

            }

        }

        // throw new Exception("Unable to load template \"{$file}\"");

        return false;

    }

    /**

    * Decode saved properties from compiled template and cache files

    */

    public function decodeProperties ($properties)

    {

        $prop = unserialize($properties);

        if (isset($prop['cache_lifetime'])) {

            $this->properties['cache_lifetime'] = $prop['cache_lifetime'];

        }

        if (isset($prop['file_dependency'])) {

            $this->properties['file_dependency'] = array_merge($this->properties['file_dependency'], $prop['file_dependency']);

            // $this->properties['file_dependency'] = array_unique($this->properties['file_dependency']);

        }

        if (!empty($prop['function'])) {

            foreach ($prop['function'] as $_name => $_data) {

                $this->smarty->template_functions[$_name]['compiled'] = str_replace('_%n', "\n", $_data['compiled']);

                $this->smarty->template_functions[$_name]['parameter'] = $_data['parameter'];

            }

        }

    }

    /**

    * Update Smarty variables in parent variable object

    */

    public function updateParentVariables ($scope = SMARTY_LOCAL_SCOPE)

    {

        foreach ($this->tpl_vars as $_key => $_variable) {

            // copy global vars back to parent

            if (isset($this->parent) && ($scope == SMARTY_PARENT_SCOPE || $this->tpl_vars[$_key]->scope == SMARTY_PARENT_SCOPE)) {

                if (isset($this->parent->tpl_vars[$_key])) {

                    // variable is already defined in parent, copy value

                    $this->parent->tpl_vars[$_key]->value = $this->tpl_vars[$_key]->value;

                } else {

                    // create variable in parent

                    $this->parent->tpl_vars[$_key] = clone $_variable;