mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-12 02:09:52 +00:00
460 lines
No EOL
13 KiB
PHP
460 lines
No EOL
13 KiB
PHP
<?php
|
|
/**
|
|
* Project: Smarty: the PHP compiling template engine
|
|
* File: SmartyBC.class.php
|
|
* SVN: $Id: $
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
* For questions, help, comments, discussion, etc., please join the
|
|
* Smarty mailing list. Send a blank e-mail to
|
|
* smarty-discussion-subscribe@googlegroups.com
|
|
*
|
|
* @link http://www.smarty.net/
|
|
* @copyright 2008 New Digital Group, Inc.
|
|
* @author Monte Ohrt <monte at ohrt dot com>
|
|
* @author Uwe Tews
|
|
* @author Rodney Rehm
|
|
* @package Smarty
|
|
*/
|
|
/**
|
|
* @ignore
|
|
*/
|
|
require(dirname(__FILE__) . '/Smarty.class.php');
|
|
|
|
/**
|
|
* Smarty Backward Compatability Wrapper Class
|
|
*
|
|
* @package Smarty
|
|
*/
|
|
class SmartyBC extends Smarty {
|
|
|
|
/**
|
|
* Smarty 2 BC
|
|
* @var string
|
|
*/
|
|
public $_version = self::SMARTY_VERSION;
|
|
|
|
/**
|
|
* Initialize new SmartyBC object
|
|
*
|
|
* @param array $options options to set during initialization, e.g. array( 'forceCompile' => false )
|
|
*/
|
|
public function __construct(array $options=array())
|
|
{
|
|
parent::__construct($options);
|
|
// register {php} tag
|
|
$this->registerPlugin('block', 'php', 'smarty_php_tag');
|
|
}
|
|
|
|
/**
|
|
* wrapper for assign_by_ref
|
|
*
|
|
* @param string $tpl_var the template variable name
|
|
* @param mixed &$value the referenced value to assign
|
|
*/
|
|
public function assign_by_ref($tpl_var, &$value)
|
|
{
|
|
$this->assignByRef($tpl_var, $value);
|
|
}
|
|
|
|
/**
|
|
* wrapper for append_by_ref
|
|
*
|
|
* @param string $tpl_var the template variable name
|
|
* @param mixed &$value the referenced value to append
|
|
* @param boolean $merge flag if array elements shall be merged
|
|
*/
|
|
public function append_by_ref($tpl_var, &$value, $merge = false)
|
|
{
|
|
$this->appendByRef($tpl_var, $value, $merge);
|
|
}
|
|
|
|
/**
|
|
* clear the given assigned template variable.
|
|
*
|
|
* @param string $tpl_var the template variable to clear
|
|
*/
|
|
public function clear_assign($tpl_var)
|
|
{
|
|
$this->clearAssign($tpl_var);
|
|
}
|
|
|
|
/**
|
|
* Registers custom function to be used in templates
|
|
*
|
|
* @param string $function the name of the template function
|
|
* @param string $function_impl the name of the PHP function to register
|
|
* @param bool $cacheable
|
|
* @param mixed $cache_attrs
|
|
*/
|
|
public function register_function($function, $function_impl, $cacheable=true, $cache_attrs=null)
|
|
{
|
|
$this->registerPlugin('function', $function, $function_impl, $cacheable, $cache_attrs);
|
|
}
|
|
|
|
/**
|
|
* Unregisters custom function
|
|
*
|
|
* @param string $function name of template function
|
|
*/
|
|
public function unregister_function($function)
|
|
{
|
|
$this->unregisterPlugin('function', $function);
|
|
}
|
|
|
|
/**
|
|
* Registers object to be used in templates
|
|
*
|
|
* @param string $object name of template object
|
|
* @param object $object_impl the referenced PHP object to register
|
|
* @param array $allowed list of allowed methods (empty = all)
|
|
* @param boolean $smarty_args smarty argument format, else traditional
|
|
* @param array $block_functs list of methods that are block format
|
|
*/
|
|
public function register_object($object, $object_impl, $allowed = array(), $smarty_args = true, $block_methods = array())
|
|
{
|
|
settype($allowed, 'array');
|
|
settype($smarty_args, 'boolean');
|
|
$this->registerObject($object, $object_impl, $allowed, $smarty_args, $block_methods);
|
|
}
|
|
|
|
/**
|
|
* Unregisters object
|
|
*
|
|
* @param string $object name of template object
|
|
*/
|
|
public function unregister_object($object)
|
|
{
|
|
$this->unregisterObject($object);
|
|
}
|
|
|
|
/**
|
|
* Registers block function to be used in templates
|
|
*
|
|
* @param string $block name of template block
|
|
* @param string $block_impl PHP function to register
|
|
* @param bool $cacheable
|
|
* @param mixed $cache_attrs
|
|
*/
|
|
public function register_block($block, $block_impl, $cacheable=true, $cache_attrs=null)
|
|
{
|
|
$this->registerPlugin('block', $block, $block_impl, $cacheable, $cache_attrs);
|
|
}
|
|
|
|
/**
|
|
* Unregisters block function
|
|
*
|
|
* @param string $block name of template function
|
|
*/
|
|
public function unregister_block($block)
|
|
{
|
|
$this->unregisterPlugin('block', $block);
|
|
}
|
|
|
|
/**
|
|
* Registers compiler function
|
|
*
|
|
* @param string $function name of template function
|
|
* @param string $function_impl name of PHP function to register
|
|
* @param bool $cacheable
|
|
*/
|
|
public function register_compiler_function($function, $function_impl, $cacheable=true)
|
|
{
|
|
$this->registerPlugin('compiler', $function, $function_impl, $cacheable);
|
|
}
|
|
|
|
/**
|
|
* Unregisters compiler function
|
|
*
|
|
* @param string $function name of template function
|
|
*/
|
|
public function unregister_compiler_function($function)
|
|
{
|
|
$this->unregisterPlugin('compiler', $function);
|
|
}
|
|
|
|
/**
|
|
* Registers modifier to be used in templates
|
|
*
|
|
* @param string $modifier name of template modifier
|
|
* @param string $modifier_impl name of PHP function to register
|
|
*/
|
|
public function register_modifier($modifier, $modifier_impl)
|
|
{
|
|
$this->registerPlugin('modifier', $modifier, $modifier_impl);
|
|
}
|
|
|
|
/**
|
|
* Unregisters modifier
|
|
*
|
|
* @param string $modifier name of template modifier
|
|
*/
|
|
public function unregister_modifier($modifier)
|
|
{
|
|
$this->unregisterPlugin('modifier', $modifier);
|
|
}
|
|
|
|
/**
|
|
* Registers a resource to fetch a template
|
|
*
|
|
* @param string $type name of resource
|
|
* @param array $functions array of functions to handle resource
|
|
*/
|
|
public function register_resource($type, $functions)
|
|
{
|
|
$this->registerResource($type, $functions);
|
|
}
|
|
|
|
/**
|
|
* Unregisters a resource
|
|
*
|
|
* @param string $type name of resource
|
|
*/
|
|
public function unregister_resource($type)
|
|
{
|
|
$this->unregisterResource($type);
|
|
}
|
|
|
|
/**
|
|
* Registers a prefilter function to apply
|
|
* to a template before compiling
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function register_prefilter($function)
|
|
{
|
|
$this->registerFilter('pre', $function);
|
|
}
|
|
|
|
/**
|
|
* Unregisters a prefilter function
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function unregister_prefilter($function)
|
|
{
|
|
$this->unregisterFilter('pre', $function);
|
|
}
|
|
|
|
/**
|
|
* Registers a postfilter function to apply
|
|
* to a compiled template after compilation
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function register_postfilter($function)
|
|
{
|
|
$this->registerFilter('post', $function);
|
|
}
|
|
|
|
/**
|
|
* Unregisters a postfilter function
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function unregister_postfilter($function)
|
|
{
|
|
$this->unregisterFilter('post', $function);
|
|
}
|
|
|
|
/**
|
|
* Registers an output filter function to apply
|
|
* to a template output
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function register_outputfilter($function)
|
|
{
|
|
$this->registerFilter('output', $function);
|
|
}
|
|
|
|
/**
|
|
* Unregisters an outputfilter function
|
|
*
|
|
* @param callable $function
|
|
*/
|
|
public function unregister_outputfilter($function)
|
|
{
|
|
$this->unregisterFilter('output', $function);
|
|
}
|
|
|
|
/**
|
|
* load a filter of specified type and name
|
|
*
|
|
* @param string $type filter type
|
|
* @param string $name filter name
|
|
*/
|
|
public function load_filter($type, $name)
|
|
{
|
|
$this->loadFilter($type, $name);
|
|
}
|
|
|
|
/**
|
|
* clear cached content for the given template and cache id
|
|
*
|
|
* @param string $tpl_file name of template file
|
|
* @param string $cache_id name of cache_id
|
|
* @param string $compile_id name of compile_id
|
|
* @param string $exp_time expiration time
|
|
* @return boolean
|
|
*/
|
|
public function clear_cache($tpl_file = null, $cache_id = null, $compile_id = null, $exp_time = null)
|
|
{
|
|
return $this->clearCache($tpl_file, $cache_id, $compile_id, $exp_time);
|
|
}
|
|
|
|
/**
|
|
* clear the entire contents of cache (all templates)
|
|
*
|
|
* @param string $exp_time expire time
|
|
* @return boolean
|
|
*/
|
|
public function clear_all_cache($exp_time = null)
|
|
{
|
|
return $this->clearCache(null, null, null, $exp_time);
|
|
}
|
|
|
|
/**
|
|
* test to see if valid cache exists for this template
|
|
*
|
|
* @param string $tpl_file name of template file
|
|
* @param string $cache_id
|
|
* @param string $compile_id
|
|
* @return boolean
|
|
*/
|
|
public function is_cached($tpl_file, $cache_id = null, $compile_id = null)
|
|
{
|
|
return $this->isCached($tpl_file, $cache_id, $compile_id);
|
|
}
|
|
|
|
/**
|
|
* clear all the assigned template variables.
|
|
*/
|
|
public function clear_all_assign()
|
|
{
|
|
$this->clearAllAssign();
|
|
}
|
|
|
|
/**
|
|
* clears compiled version of specified template resource,
|
|
* or all compiled template files if one is not specified.
|
|
* This function is for advanced use only, not normally needed.
|
|
*
|
|
* @param string $tpl_file
|
|
* @param string $compile_id
|
|
* @param string $exp_time
|
|
* @return boolean results of {@link smarty_core_rm_auto()}
|
|
*/
|
|
public function clear_compiled_tpl($tpl_file = null, $compile_id = null, $exp_time = null)
|
|
{
|
|
return $this->clearCompiledTemplate($tpl_file, $compile_id, $exp_time);
|
|
}
|
|
|
|
/**
|
|
* Checks whether requested template exists.
|
|
*
|
|
* @param string $tpl_file
|
|
* @return boolean
|
|
*/
|
|
public function template_exists($tpl_file)
|
|
{
|
|
return $this->templateExists($tpl_file);
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing template variables
|
|
*
|
|
* @param string $name
|
|
* @return array
|
|
*/
|
|
public function get_template_vars($name=null)
|
|
{
|
|
return $this->getTemplateVars($name);
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing config variables
|
|
*
|
|
* @param string $name
|
|
* @return array
|
|
*/
|
|
public function get_config_vars($name=null)
|
|
{
|
|
return $this->getConfigVars($name);
|
|
}
|
|
|
|
/**
|
|
* load configuration values
|
|
*
|
|
* @param string $file
|
|
* @param string $section
|
|
* @param string $scope
|
|
*/
|
|
public function config_load($file, $section = null, $scope = 'global')
|
|
{
|
|
$this->ConfigLoad($file, $section, $scope);
|
|
}
|
|
|
|
/**
|
|
* return a reference to a registered object
|
|
*
|
|
* @param string $name
|
|
* @return object
|
|
*/
|
|
public function get_registered_object($name)
|
|
{
|
|
return $this->getRegisteredObject($name);
|
|
}
|
|
|
|
/**
|
|
* clear configuration values
|
|
*
|
|
* @param string $var
|
|
*/
|
|
public function clear_config($var = null)
|
|
{
|
|
$this->clearConfig($var);
|
|
}
|
|
|
|
/**
|
|
* trigger Smarty error
|
|
*
|
|
* @param string $error_msg
|
|
* @param integer $error_type
|
|
*/
|
|
public function trigger_error($error_msg, $error_type = E_USER_WARNING)
|
|
{
|
|
trigger_error("Smarty error: $error_msg", $error_type);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Smarty {php}{/php} block function
|
|
*
|
|
* @param array $params parameter list
|
|
* @param string $content contents of the block
|
|
* @param object $template template object
|
|
* @param boolean &$repeat repeat flag
|
|
* @return string content re-formatted
|
|
*/
|
|
function smarty_php_tag($params, $content, $template, &$repeat)
|
|
{
|
|
eval($content);
|
|
return '';
|
|
}
|
|
|
|
?>
|