Documentación GVHIDRA 3.1.5
Referencia de la Clase Smarty
Diagrama de herencias de Smarty
Smarty_Compiler Smarty_Phrame

Métodos públicos

 Smarty ()
 assign ($tpl_var, $value=null)
 assign_by_ref ($tpl_var, &$value)
 append ($tpl_var, $value=null, $merge=false)
 append_by_ref ($tpl_var, &$value, $merge=false)
 clear_assign ($tpl_var)
 register_function ($function, $function_impl, $cacheable=true, $cache_attrs=null)
 unregister_function ($function)
 register_object ($object, &$object_impl, $allowed=array(), $smarty_args=true, $block_methods=array())
 unregister_object ($object)
 register_block ($block, $block_impl, $cacheable=true, $cache_attrs=null)
 unregister_block ($block)
 register_compiler_function ($function, $function_impl, $cacheable=true)
 unregister_compiler_function ($function)
 register_modifier ($modifier, $modifier_impl)
 unregister_modifier ($modifier)
 register_resource ($type, $functions)
 unregister_resource ($type)
 register_prefilter ($function)
 unregister_prefilter ($function)
 register_postfilter ($function)
 unregister_postfilter ($function)
 register_outputfilter ($function)
 unregister_outputfilter ($function)
 load_filter ($type, $name)
 clear_cache ($tpl_file=null, $cache_id=null, $compile_id=null, $exp_time=null)
 clear_all_cache ($exp_time=null)
 is_cached ($tpl_file, $cache_id=null, $compile_id=null)
 clear_all_assign ()
 clear_compiled_tpl ($tpl_file=null, $compile_id=null, $exp_time=null)
 template_exists ($tpl_file)
get_template_vars ($name=null)
get_config_vars ($name=null)
 trigger_error ($error_msg, $error_type=E_USER_WARNING)
 display ($resource_name, $cache_id=null, $compile_id=null)
 fetch ($resource_name, $cache_id=null, $compile_id=null, $display=false)
 config_load ($file, $section=null, $scope= 'global')
get_registered_object ($name)
 clear_config ($var=null)
 _get_plugin_filepath ($type, $name)
 _is_compiled ($resource_name, $compile_path)
 _compile_resource ($resource_name, $compile_path)
 _compile_source ($resource_name, &$source_content, &$compiled_content, $cache_include_path=null)
 _get_compile_path ($resource_name)
 _fetch_resource_info (&$params)
 _parse_resource_name (&$params)
 _run_mod_handler ()
 _dequote ($string)
 _read_file ($filename)
 _get_auto_filename ($auto_base, $auto_source=null, $auto_id=null)
 _unlink ($resource, $exp_time=null)
 _get_auto_id ($cache_id=null, $compile_id=null)
 _trigger_fatal_error ($error_msg, $tpl_file=null, $tpl_line=null, $file=null, $line=null, $error_type=E_USER_ERROR)
 _process_compiled_include_callback ($match)
 _smarty_include ($params)
_smarty_cache_attrs ($cache_serial, $count)
 _include ($filename, $once=false, $params=null)
 _eval ($code, $params=null)

Campos de datos

 $template_dir = 'templates'
 $compile_dir = 'templates_c'
 $config_dir = 'configs'
 $plugins_dir = array('plugins')
 $debugging = false
 $error_reporting = null
 $debug_tpl = ''
 $debugging_ctrl = 'NONE'
 $compile_check = true
 $force_compile = false
 $caching = 0
 $cache_dir = 'cache'
 $cache_lifetime = 3600
 $cache_modified_check = false
 $php_handling = SMARTY_PHP_PASSTHRU
 $security = false
 $secure_dir = array()
 $security_settings
 $trusted_dir = array()
 $left_delimiter = '{'
 $right_delimiter = '}'
 $request_vars_order = 'EGPCS'
 $request_use_auto_globals = true
 $compile_id = null
 $use_sub_dirs = false
 $default_modifiers = array()
 $default_resource_type = 'file'
 $cache_handler_func = null
 $autoload_filters = array()
 $config_overwrite = true
 $config_booleanize = true
 $config_read_hidden = false
 $config_fix_newlines = true
 $default_template_handler_func = ''
 $compiler_file = 'Smarty_Compiler.class.php'
 $compiler_class = 'Smarty_Compiler'
 $config_class = 'Config_File'
 $_tpl_vars = array()
 $_smarty_vars = null
 $_sections = array()
 $_foreach = array()
 $_tag_stack = array()
 $_conf_obj = null
 $_config = array(array('vars' => array(), 'files' => array()))
 $_smarty_md5 = 'f8d698aea36fcbead2b9d5359ffca76f'
 $_version = '2.6.14'
 $_inclusion_depth = 0
 $_compile_id = null
 $_smarty_debug_id = 'SMARTY_DEBUG'
 $_smarty_debug_info = array()
 $_cache_info = array()
 $_file_perms = 0644
 $_dir_perms = 0771
 $_reg_objects = array()
 $_plugins
 $_cache_serials = array()
 $_cache_include = null
 $_cache_including = false

Descripción detallada

Definición en la línea 64 del archivo Smarty.class.php.


Documentación de las funciones miembro

_compile_resource ( resource_name,
compile_path 
)

compile the template

Parámetros:
string$resource_name
string$compile_path
Devuelve:
boolean

Definición en la línea 1413 del archivo Smarty.class.php.

    {

        $_params = array('resource_name' => $resource_name);
        if (!$this->_fetch_resource_info($_params)) {
            return false;
        }

        $_source_content = $_params['source_content'];
        $_cache_include    = substr($compile_path, 0, -4).'.inc';

        if ($this->_compile_source($resource_name, $_source_content, $_compiled_content, $_cache_include)) {
            // if a _cache_serial was set, we also have to write an include-file:
            if ($this->_cache_include_info) {
                require_once(SMARTY_CORE_DIR . 'core.write_compiled_include.php');
                smarty_core_write_compiled_include(array_merge($this->_cache_include_info, array('compiled_content'=>$_compiled_content, 'resource_name'=>$resource_name)),  $this);
            }

            $_params = array('compile_path'=>$compile_path, 'compiled_content' => $_compiled_content);
            require_once(SMARTY_CORE_DIR . 'core.write_compiled_resource.php');
            smarty_core_write_compiled_resource($_params, $this);

            return true;
        } else {
            return false;
        }

    }
_compile_source ( resource_name,
&$  source_content,
&$  compiled_content,
cache_include_path = null 
)

compile the given source

Parámetros:
string$resource_name
string$source_content
string$compiled_content
Devuelve:
boolean

Definición en la línea 1450 del archivo Smarty.class.php.

    {
        if (file_exists(SMARTY_DIR . $this->compiler_file)) {
            require_once(SMARTY_DIR . $this->compiler_file);
        } else {
            // use include_path
            require_once($this->compiler_file);
        }


        $smarty_compiler = new $this->compiler_class;

        $smarty_compiler->template_dir      = $this->template_dir;
        $smarty_compiler->compile_dir       = $this->compile_dir;
        $smarty_compiler->plugins_dir       = $this->plugins_dir;
        $smarty_compiler->config_dir        = $this->config_dir;
        $smarty_compiler->force_compile     = $this->force_compile;
        $smarty_compiler->caching           = $this->caching;
        $smarty_compiler->php_handling      = $this->php_handling;
        $smarty_compiler->left_delimiter    = $this->left_delimiter;
        $smarty_compiler->right_delimiter   = $this->right_delimiter;
        $smarty_compiler->_version          = $this->_version;
        $smarty_compiler->security          = $this->security;
        $smarty_compiler->secure_dir        = $this->secure_dir;
        $smarty_compiler->security_settings = $this->security_settings;
        $smarty_compiler->trusted_dir       = $this->trusted_dir;
        $smarty_compiler->use_sub_dirs      = $this->use_sub_dirs;
        $smarty_compiler->_reg_objects      = &$this->_reg_objects;
        $smarty_compiler->_plugins          = &$this->_plugins;
        $smarty_compiler->_tpl_vars         = &$this->_tpl_vars;
        $smarty_compiler->default_modifiers = $this->default_modifiers;
        $smarty_compiler->compile_id        = $this->_compile_id;
        $smarty_compiler->_config            = $this->_config;
        $smarty_compiler->request_use_auto_globals  = $this->request_use_auto_globals;

        if (isset($cache_include_path) && isset($this->_cache_serials[$cache_include_path])) {
            $smarty_compiler->_cache_serial = $this->_cache_serials[$cache_include_path];
        }
        $smarty_compiler->_cache_include = $cache_include_path;


        $_results = $smarty_compiler->_compile_file($resource_name, $source_content, $compiled_content);

        if ($smarty_compiler->_cache_serial) {
            $this->_cache_include_info = array(
                'cache_serial'=>$smarty_compiler->_cache_serial
                ,'plugins_code'=>$smarty_compiler->_plugins_code
                ,'include_file_path' => $cache_include_path);

        } else {
            $this->_cache_include_info = null;

        }

        return $_results;
    }
_dequote ( string)

Remove starting and ending quotes from the string

Parámetros:
string$string
Devuelve:
string

Definición en la línea 1699 del archivo Smarty.class.php.

    {
        if ((substr($string, 0, 1) == "'" || substr($string, 0, 1) == '"') &&
            substr($string, -1) == substr($string, 0, 1))
            return substr($string, 1, -1);
        else
            return $string;
    }
_eval ( code,
params = null 
)

wrapper for eval() retaining $this

Devuelve:
mixed

Definición en la línea 1934 del archivo Smarty.class.php.

    {
        return eval($code);
    }
_fetch_resource_info ( &$  params)

fetch the template info. Gets timestamp, and source if get_source is true

sets $source_content to the source of the template, and $resource_timestamp to its time stamp

Parámetros:
string$resource_name
string$source_content
integer$resource_timestamp
boolean$get_source
boolean$quiet
Devuelve:
boolean

Definición en la línea 1533 del archivo Smarty.class.php.

    {
        if(!isset($params['get_source'])) { $params['get_source'] = true; }
        if(!isset($params['quiet'])) { $params['quiet'] = false; }

        $_return = false;
        $_params = array('resource_name' => $params['resource_name']) ;
        if (isset($params['resource_base_path']))
            $_params['resource_base_path'] = $params['resource_base_path'];
        else
            $_params['resource_base_path'] = $this->template_dir;

        if ($this->_parse_resource_name($_params)) {
            $_resource_type = $_params['resource_type'];
            $_resource_name = $_params['resource_name'];
            switch ($_resource_type) {
                case 'file':
                    if ($params['get_source']) {
                        $params['source_content'] = $this->_read_file($_resource_name);
                    }
                    $params['resource_timestamp'] = filemtime($_resource_name);
                    $_return = is_file($_resource_name);
                    break;

                default:
                    // call resource functions to fetch the template source and timestamp
                    if ($params['get_source']) {
                        $_source_return = isset($this->_plugins['resource'][$_resource_type]) &&
                            call_user_func_array($this->_plugins['resource'][$_resource_type][0][0],
                                                 array($_resource_name, &$params['source_content'], &$this));
                    } else {
                        $_source_return = true;
                    }

                    $_timestamp_return = isset($this->_plugins['resource'][$_resource_type]) &&
                        call_user_func_array($this->_plugins['resource'][$_resource_type][0][1],
                                             array($_resource_name, &$params['resource_timestamp'], &$this));

                    $_return = $_source_return && $_timestamp_return;
                    break;
            }
        }

        if (!$_return) {
            // see if we can get a template with the default template handler
            if (!empty($this->default_template_handler_func)) {
                if (!is_callable($this->default_template_handler_func)) {
                    $this->trigger_error("default template handler function \"$this->default_template_handler_func\" doesn't exist.");
                } else {
                    $_return = call_user_func_array(
                        $this->default_template_handler_func,
                        array($_params['resource_type'], $_params['resource_name'], &$params['source_content'], &$params['resource_timestamp'], &$this));
                }
            }
        }

        if (!$_return) {
            if (!$params['quiet']) {
                $this->trigger_error('unable to read resource: "' . $params['resource_name'] . '"');
            }
        } else if ($_return && $this->security) {
            require_once(SMARTY_CORE_DIR . 'core.is_secure.php');
            if (!smarty_core_is_secure($_params, $this)) {
                if (!$params['quiet'])
                    $this->trigger_error('(secure mode) accessing "' . $params['resource_name'] . '" is not allowed');
                $params['source_content'] = null;
                $params['resource_timestamp'] = null;
                return false;
            }
        }
        return $_return;
    }
_get_auto_filename ( auto_base,
auto_source = null,
auto_id = null 
)

get a concrete filename for automagically created content

Parámetros:
string$auto_base
string$auto_source
string$auto_id
Devuelve:
string string|null string|null

Definición en la línea 1739 del archivo Smarty.class.php.

    {
        $_compile_dir_sep =  $this->use_sub_dirs ? DIRECTORY_SEPARATOR : '^';
        $_return = $auto_base . DIRECTORY_SEPARATOR;

        if(isset($auto_id)) {
            // make auto_id safe for directory names
            $auto_id = str_replace('%7C',$_compile_dir_sep,(urlencode($auto_id)));
            // split into separate directories
            $_return .= $auto_id . $_compile_dir_sep;
        }

        if(isset($auto_source)) {
            // make source name safe for filename
            $_filename = urlencode(basename($auto_source));
            $_crc32 = sprintf('%08X', crc32($auto_source));
            // prepend %% to avoid name conflicts with
            // with $params['auto_id'] names
            $_crc32 = substr($_crc32, 0, 2) . $_compile_dir_sep .
                      substr($_crc32, 0, 3) . $_compile_dir_sep . $_crc32;
            $_return .= '%%' . $_crc32 . '%%' . $_filename;
        }

        return $_return;
    }
_get_auto_id ( cache_id = null,
compile_id = null 
)

returns an auto_id for auto-file-functions

Parámetros:
string$cache_id
string$compile_id
Devuelve:
string|null

Definición en la línea 1789 del archivo Smarty.class.php.

                                                            {
    if (isset($cache_id))
        return (isset($compile_id)) ? $cache_id . '|' . $compile_id  : $cache_id;
    elseif(isset($compile_id))
        return $compile_id;
    else
        return null;
    }
_get_compile_path ( resource_name)

Get the compile path for this resource

Parámetros:
string$resource_name
Devuelve:
string results of _get_auto_filename()

Definición en la línea 1513 del archivo Smarty.class.php.

    {
        return $this->_get_auto_filename($this->compile_dir, $resource_name,
                                         $this->_compile_id) . '.php';
    }
_get_plugin_filepath ( type,
name 
)

get filepath of requested plugin

Parámetros:
string$type
string$name
Devuelve:
string|false

Definición en la línea 1366 del archivo Smarty.class.php.

    {
        $_params = array('type' => $type, 'name' => $name);
        require_once(SMARTY_CORE_DIR . 'core.assemble_plugin_filepath.php');
        return smarty_core_assemble_plugin_filepath($_params, $this);
    }
_include ( filename,
once = false,
params = null 
)

wrapper for include() retaining $this

Devuelve:
mixed

Definición en la línea 1920 del archivo Smarty.class.php.

    {
        if ($once) {
            return include_once($filename);
        } else {
            return include($filename);
        }
    }
_is_compiled ( resource_name,
compile_path 
)

test if resource needs compiling

Parámetros:
string$resource_name
string$compile_path
Devuelve:
boolean

Definición en la línea 1380 del archivo Smarty.class.php.

    {
        if (!$this->force_compile && file_exists($compile_path)) {
            if (!$this->compile_check) {
                // no need to check compiled file
                return true;
            } else {
                // get file source and timestamp
                $_params = array('resource_name' => $resource_name, 'get_source'=>false);
                if (!$this->_fetch_resource_info($_params)) {
                    return false;
                }
                if ($_params['resource_timestamp'] <= filemtime($compile_path)) {
                    // template not expired, no recompile
                    return true;
                } else {
                    // compile template
                    return false;
                }
            }
        } else {
            // compiled template does not exist, or forced compile
            return false;
        }
    }
_parse_resource_name ( &$  params)

parse out the type and name from the resource

Parámetros:
string$resource_base_path
string$resource_name
string$resource_type
string$resource_name
Devuelve:
boolean

Definición en la línea 1617 del archivo Smarty.class.php.

    {

        // split tpl_path by the first colon
        $_resource_name_parts = explode(':', $params['resource_name'], 2);

        if (count($_resource_name_parts) == 1) {
            // no resource type given
            $params['resource_type'] = $this->default_resource_type;
            $params['resource_name'] = $_resource_name_parts[0];
        } else {
            if(strlen($_resource_name_parts[0]) == 1) {
                // 1 char is not resource type, but part of filepath
                $params['resource_type'] = $this->default_resource_type;
                $params['resource_name'] = $params['resource_name'];
            } else {
                $params['resource_type'] = $_resource_name_parts[0];
                $params['resource_name'] = $_resource_name_parts[1];
            }
        }

        if ($params['resource_type'] == 'file') {
            if (!preg_match('/^([\/\\\\]|[a-zA-Z]:[\/\\\\])/', $params['resource_name'])) {
                // relative pathname to $params['resource_base_path']
                // use the first directory where the file is found
                foreach ((array)$params['resource_base_path'] as $_curr_path) {
                    $_fullpath = $_curr_path . DIRECTORY_SEPARATOR . $params['resource_name'];
                    if (file_exists($_fullpath) && is_file($_fullpath)) {
                        $params['resource_name'] = $_fullpath;
                        return true;
                    }
                    // didn't find the file, try include_path
                    $_params = array('file_path' => $_fullpath);
                    require_once(SMARTY_CORE_DIR . 'core.get_include_path.php');
                    if(smarty_core_get_include_path($_params, $this)) {
                        $params['resource_name'] = $_params['new_file_path'];
                        return true;
                    }
                }
                return false;
            } else {
                /* absolute path */
                return file_exists($params['resource_name']);
            }
        } elseif (empty($this->_plugins['resource'][$params['resource_type']])) {
            $_params = array('type' => $params['resource_type']);
            require_once(SMARTY_CORE_DIR . 'core.load_resource_plugin.php');
            smarty_core_load_resource_plugin($_params, $this);
        }

        return true;
    }
_process_compiled_include_callback ( match)

callback function for preg_replace, to call a non-cacheable block

Devuelve:
string

Definición en la línea 1828 del archivo Smarty.class.php.

                                                        {
        $_func = '_smarty_tplfunc_'.$match[2].'_'.$match[3];
        ob_start();
        $_func($this);
        $_ret = ob_get_contents();
        ob_end_clean();
        return $_ret;
    }
_read_file ( filename)

read in a file

Parámetros:
string$filename
Devuelve:
string

Definición en la línea 1715 del archivo Smarty.class.php.

    {
        if ( file_exists($filename) && ($fd = @fopen($filename, 'rb')) ) {
            $contents = '';
            while (!feof($fd)) {
                $contents .= fread($fd, 8192);
            }
            fclose($fd);
            return $contents;
        } else {
            return false;
        }
    }
_run_mod_handler ( )

Handle modifiers

Parámetros:
string | null$modifier_name
array | null$map_array
Devuelve:
string result of modifiers

Definición en la línea 1678 del archivo Smarty.class.php.

    {
        $_args = func_get_args();
        list($_modifier_name, $_map_array) = array_splice($_args, 0, 2);
        list($_func_name, $_tpl_file, $_tpl_line) =
            $this->_plugins['modifier'][$_modifier_name];

        $_var = $_args[0];
        foreach ($_var as $_key => $_val) {
            $_args[0] = $_val;
            $_var[$_key] = call_user_func_array($_func_name, $_args);
        }
        return $_var;
    }
& _smarty_cache_attrs ( cache_serial,
count 
)

get or set an array of cached attributes for function that is not cacheable

Devuelve:
array

Definición en la línea 1897 del archivo Smarty.class.php.

                                                         {
        $_cache_attrs =& $this->_cache_info['cache_attrs'][$cache_serial][$count];

        if ($this->_cache_including) {
            /* return next set of cache_attrs */
            $_return = current($_cache_attrs);
            next($_cache_attrs);
            return $_return;

        } else {
            /* add a reference to a new set of cache_attrs */
            $_cache_attrs[] = array();
            return $_cache_attrs[count($_cache_attrs)-1];

        }

    }
_smarty_include ( params)

called for included templates

Parámetros:
string$_smarty_include_tpl_file
string$_smarty_include_vars

Definición en la línea 1847 del archivo Smarty.class.php.

    {
        if ($this->debugging) {
            $_params = array();
            require_once(SMARTY_CORE_DIR . 'core.get_microtime.php');
            $debug_start_time = smarty_core_get_microtime($_params, $this);
            $this->_smarty_debug_info[] = array('type'      => 'template',
                                                  'filename'  => $params['smarty_include_tpl_file'],
                                                  'depth'     => ++$this->_inclusion_depth);
            $included_tpls_idx = count($this->_smarty_debug_info) - 1;
        }

        $this->_tpl_vars = array_merge($this->_tpl_vars, $params['smarty_include_vars']);

        // config vars are treated as local, so push a copy of the
        // current ones onto the front of the stack
        array_unshift($this->_config, $this->_config[0]);

        $_smarty_compile_path = $this->_get_compile_path($params['smarty_include_tpl_file']);


        if ($this->_is_compiled($params['smarty_include_tpl_file'], $_smarty_compile_path)
            || $this->_compile_resource($params['smarty_include_tpl_file'], $_smarty_compile_path))
        {
            include($_smarty_compile_path);
        }

        // pop the local vars off the front of the stack
        array_shift($this->_config);

        $this->_inclusion_depth--;

        if ($this->debugging) {
            // capture time for debugging info
            $_params = array();
            require_once(SMARTY_CORE_DIR . 'core.get_microtime.php');
            $this->_smarty_debug_info[$included_tpls_idx]['exec_time'] = smarty_core_get_microtime($_params, $this) - $debug_start_time;
        }

        if ($this->caching) {
            $this->_cache_info['template'][$params['smarty_include_tpl_file']] = true;
        }
    }
_trigger_fatal_error ( error_msg,
tpl_file = null,
tpl_line = null,
file = null,
line = null,
error_type = E_USER_ERROR 
)

trigger Smarty plugin error

Parámetros:
string$error_msg
string$tpl_file
integer$tpl_line
string$file
integer$line
integer$error_type

Definición en la línea 1808 del archivo Smarty.class.php.

    {
        if(isset($file) && isset($line)) {
            $info = ' ('.basename($file).", line $line)";
        } else {
            $info = '';
        }
        if (isset($tpl_line) && isset($tpl_file)) {
            $this->trigger_error('[in ' . $tpl_file . ' line ' . $tpl_line . "]: $error_msg$info", $error_type);
        } else {
            $this->trigger_error($error_msg . $info, $error_type);
        }
    }
_unlink ( resource,
exp_time = null 
)

unlink a file, possibly using expiration time

Parámetros:
string$resource
integer$exp_time

Definición en la línea 1771 del archivo Smarty.class.php.

    {
        if(isset($exp_time)) {
            if(time() - @filemtime($resource) >= $exp_time) {
                return @unlink($resource);
            }
        } else {
            return @unlink($resource);
        }
    }
append ( tpl_var,
value = null,
merge = false 
)

appends values to template variables

Parámetros:
array | string$tpl_varthe template variable name(s)
mixed$valuethe value to append

Definición en la línea 612 del archivo Smarty.class.php.

    {
        if (is_array($tpl_var)) {
            // $tpl_var is an array, ignore $value
            foreach ($tpl_var as $_key => $_val) {
                if ($_key != '') {
                    if(!@is_array($this->_tpl_vars[$_key])) {
                        settype($this->_tpl_vars[$_key],'array');
                    }
                    if($merge && is_array($_val)) {
                        foreach($_val as $_mkey => $_mval) {
                            $this->_tpl_vars[$_key][$_mkey] = $_mval;
                        }
                    } else {
                        $this->_tpl_vars[$_key][] = $_val;
                    }
                }
            }
        } else {
            if ($tpl_var != '' && isset($value)) {
                if(!@is_array($this->_tpl_vars[$tpl_var])) {
                    settype($this->_tpl_vars[$tpl_var],'array');
                }
                if($merge && is_array($value)) {
                    foreach($value as $_mkey => $_mval) {
                        $this->_tpl_vars[$tpl_var][$_mkey] = $_mval;
                    }
                } else {
                    $this->_tpl_vars[$tpl_var][] = $value;
                }
            }
        }
    }
append_by_ref ( tpl_var,
&$  value,
merge = false 
)

appends values to template variables by reference

Parámetros:
string$tpl_varthe template variable name
mixed$valuethe referenced value to append

Definición en la línea 652 del archivo Smarty.class.php.

    {
        if ($tpl_var != '' && isset($value)) {
            if(!@is_array($this->_tpl_vars[$tpl_var])) {
             settype($this->_tpl_vars[$tpl_var],'array');
            }
            if ($merge && is_array($value)) {
                foreach($value as $_key => $_val) {
                    $this->_tpl_vars[$tpl_var][$_key] = &$value[$_key];
                }
            } else {
                $this->_tpl_vars[$tpl_var][] = &$value;
            }
        }
    }
assign ( tpl_var,
value = null 
)

assigns values to template variables

Parámetros:
array | string$tpl_varthe template variable name(s)
mixed$valuethe value to assign

Definición en la línea 580 del archivo Smarty.class.php.

    {
        if (is_array($tpl_var)){
            foreach ($tpl_var as $key => $val) {
                if ($key != '') {
                    $this->_tpl_vars[$key] = $val;
                }
            }
        } else {
            if ($tpl_var != '')
                $this->_tpl_vars[$tpl_var] = $value;
        }
    }
assign_by_ref ( tpl_var,
&$  value 
)

assigns values to template variables by reference

Parámetros:
string$tpl_varthe template variable name
mixed$valuethe referenced value to assign

Definición en la línea 600 del archivo Smarty.class.php.

    {
        if ($tpl_var != '')
            $this->_tpl_vars[$tpl_var] = &$value;
    }
clear_all_assign ( )

clear all the assigned template variables.

Definición en la línea 1006 del archivo Smarty.class.php.

    {
        $this->_tpl_vars = array();
    }
clear_all_cache ( exp_time = null)

clear the entire contents of cache (all templates)

Parámetros:
string$exp_timeexpire time
Devuelve:
boolean results of smarty_core_rm_auto()

Definición en la línea 970 del archivo Smarty.class.php.

    {
        return $this->clear_cache(null, null, null, $exp_time);
    }
clear_assign ( tpl_var)

clear the given assigned template variable.

Parámetros:
string$tpl_varthe template variable to clear

Definición en la línea 674 del archivo Smarty.class.php.

    {
        if (is_array($tpl_var))
            foreach ($tpl_var as $curr_var)
                unset($this->_tpl_vars[$curr_var]);
        else
            unset($this->_tpl_vars[$tpl_var]);
    }
clear_cache ( tpl_file = null,
cache_id = null,
compile_id = null,
exp_time = null 
)

clear cached content for the given template and cache id

Parámetros:
string$tpl_filename of template file
string$cache_idname of cache_id
string$compile_idname of compile_id
string$exp_timeexpiration time
Devuelve:
boolean

Definición en la línea 938 del archivo Smarty.class.php.

    {

        if (!isset($compile_id))
            $compile_id = $this->compile_id;

        if (!isset($tpl_file))
            $compile_id = null;

        $_auto_id = $this->_get_auto_id($cache_id, $compile_id);

        if (!empty($this->cache_handler_func)) {
            return call_user_func_array($this->cache_handler_func,
                                  array('clear', &$this, &$dummy, $tpl_file, $cache_id, $compile_id, $exp_time));
        } else {
            $_params = array('auto_base' => $this->cache_dir,
                            'auto_source' => $tpl_file,
                            'auto_id' => $_auto_id,
                            'exp_time' => $exp_time);
            require_once(SMARTY_CORE_DIR . 'core.rm_auto.php');
            return smarty_core_rm_auto($_params, $this);
        }

    }
clear_compiled_tpl ( tpl_file = null,
compile_id = null,
exp_time = null 
)

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.

Parámetros:
string$tpl_file
string$compile_id
string$exp_time
Devuelve:
boolean results of smarty_core_rm_auto()

Definición en la línea 1021 del archivo Smarty.class.php.

    {
        if (!isset($compile_id)) {
            $compile_id = $this->compile_id;
        }
        $_params = array('auto_base' => $this->compile_dir,
                        'auto_source' => $tpl_file,
                        'auto_id' => $compile_id,
                        'exp_time' => $exp_time,
                        'extensions' => array('.inc', '.php'));
        require_once(SMARTY_CORE_DIR . 'core.rm_auto.php');
        return smarty_core_rm_auto($_params, $this);
    }
clear_config ( var = null)

clear configuration values

Parámetros:
string$var

Definición en la línea 1348 del archivo Smarty.class.php.

    {
        if(!isset($var)) {
            // clear all values
            $this->_config = array(array('vars'  => array(),
                                         'files' => array()));
        } else {
            unset($this->_config[0]['vars'][$var]);
        }
    }
config_load ( file,
section = null,
scope = 'global' 
)

load configuration values

Parámetros:
string$file
string$section
string$scope

Definición en la línea 1321 del archivo Smarty.class.php.

    {
        require_once($this->_get_plugin_filepath('function', 'config_load'));
        smarty_function_config_load(array('file' => $file, 'section' => $section, 'scope' => $scope), $this);
    }
display ( resource_name,
cache_id = null,
compile_id = null 
)

executes & displays the template results

Parámetros:
string$resource_name
string$cache_id
string$compile_id

Definición en la línea 1106 del archivo Smarty.class.php.

    {
        $this->fetch($resource_name, $cache_id, $compile_id, true);
    }
fetch ( resource_name,
cache_id = null,
compile_id = null,
display = false 
)

executes & returns or displays the template results

Parámetros:
string$resource_name
string$cache_id
string$compile_id
boolean$display

Definición en la línea 1119 del archivo Smarty.class.php.

    {
        static $_cache_info = array();
        
        $_smarty_old_error_level = $this->debugging ? error_reporting() : error_reporting(isset($this->error_reporting)
               ? $this->error_reporting : error_reporting() & ~E_NOTICE);

        if (!$this->debugging && $this->debugging_ctrl == 'URL') {
            $_query_string = $this->request_use_auto_globals ? $_SERVER['QUERY_STRING'] : $GLOBALS['HTTP_SERVER_VARS']['QUERY_STRING'];
            if (@strstr($_query_string, $this->_smarty_debug_id)) {
                if (@strstr($_query_string, $this->_smarty_debug_id . '=on')) {
                    // enable debugging for this browser session
                    @setcookie('SMARTY_DEBUG', true);
                    $this->debugging = true;
                } elseif (@strstr($_query_string, $this->_smarty_debug_id . '=off')) {
                    // disable debugging for this browser session
                    @setcookie('SMARTY_DEBUG', false);
                    $this->debugging = false;
                } else {
                    // enable debugging for this page
                    $this->debugging = true;
                }
            } else {
                $this->debugging = (bool)($this->request_use_auto_globals ? @$_COOKIE['SMARTY_DEBUG'] : @$GLOBALS['HTTP_COOKIE_VARS']['SMARTY_DEBUG']);
            }
        }

        if ($this->debugging) {
            // capture time for debugging info
            $_params = array();
            require_once(SMARTY_CORE_DIR . 'core.get_microtime.php');
            $_debug_start_time = smarty_core_get_microtime($_params, $this);
            $this->_smarty_debug_info[] = array('type'      => 'template',
                                                'filename'  => $resource_name,
                                                'depth'     => 0);
            $_included_tpls_idx = count($this->_smarty_debug_info) - 1;
        }

        if (!isset($compile_id)) {
            $compile_id = $this->compile_id;
        }

        $this->_compile_id = $compile_id;
        $this->_inclusion_depth = 0;

        if ($this->caching) {
            // save old cache_info, initialize cache_info
            array_push($_cache_info, $this->_cache_info);
            $this->_cache_info = array();
            $_params = array(
                'tpl_file' => $resource_name,
                'cache_id' => $cache_id,
                'compile_id' => $compile_id,
                'results' => null
            );
            require_once(SMARTY_CORE_DIR . 'core.read_cache_file.php');
            if (smarty_core_read_cache_file($_params, $this)) {
                $_smarty_results = $_params['results'];
                if (!empty($this->_cache_info['insert_tags'])) {
                    $_params = array('plugins' => $this->_cache_info['insert_tags']);
                    require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
                    smarty_core_load_plugins($_params, $this);
                    $_params = array('results' => $_smarty_results);
                    require_once(SMARTY_CORE_DIR . 'core.process_cached_inserts.php');
                    $_smarty_results = smarty_core_process_cached_inserts($_params, $this);
                }
                if (!empty($this->_cache_info['cache_serials'])) {
                    $_params = array('results' => $_smarty_results);
                    require_once(SMARTY_CORE_DIR . 'core.process_compiled_include.php');
                    $_smarty_results = smarty_core_process_compiled_include($_params, $this);
                }


                if ($display) {
                    if ($this->debugging)
                    {
                        // capture time for debugging info
                        $_params = array();
                        require_once(SMARTY_CORE_DIR . 'core.get_microtime.php');
                        $this->_smarty_debug_info[$_included_tpls_idx]['exec_time'] = smarty_core_get_microtime($_params, $this) - $_debug_start_time;
                        require_once(SMARTY_CORE_DIR . 'core.display_debug_console.php');
                        $_smarty_results .= smarty_core_display_debug_console($_params, $this);
                    }
                    if ($this->cache_modified_check) {
                        $_server_vars = ($this->request_use_auto_globals) ? $_SERVER : $GLOBALS['HTTP_SERVER_VARS'];
                        $_last_modified_date = @substr($_server_vars['HTTP_IF_MODIFIED_SINCE'], 0, strpos($_server_vars['HTTP_IF_MODIFIED_SINCE'], 'GMT') + 3);
                        $_gmt_mtime = gmdate('D, d M Y H:i:s', $this->_cache_info['timestamp']).' GMT';
                        if (@count($this->_cache_info['insert_tags']) == 0
                            && !$this->_cache_serials
                            && $_gmt_mtime == $_last_modified_date) {
                            if (php_sapi_name()=='cgi')
                                header('Status: 304 Not Modified');
                            else
                                header('HTTP/1.1 304 Not Modified');

                        } else {
                            header('Last-Modified: '.$_gmt_mtime);
                            echo $_smarty_results;
                        }
                    } else {
                            echo $_smarty_results;
                    }
                    error_reporting($_smarty_old_error_level);
                    // restore initial cache_info
                    $this->_cache_info = array_pop($_cache_info);
                    return true;
                } else {
                    error_reporting($_smarty_old_error_level);
                    // restore initial cache_info
                    $this->_cache_info = array_pop($_cache_info);
                    return $_smarty_results;
                }
            } else {
                $this->_cache_info['template'][$resource_name] = true;
                if ($this->cache_modified_check && $display) {
                    header('Last-Modified: '.gmdate('D, d M Y H:i:s', time()).' GMT');
                }
            }
        }

        // load filters that are marked as autoload
        if (count($this->autoload_filters)) {
            foreach ($this->autoload_filters as $_filter_type => $_filters) {
                foreach ($_filters as $_filter) {
                    $this->load_filter($_filter_type, $_filter);
                }
            }
        }

        $_smarty_compile_path = $this->_get_compile_path($resource_name);

        // if we just need to display the results, don't perform output
        // buffering - for speed
        $_cache_including = $this->_cache_including;
        $this->_cache_including = false;
        if ($display && !$this->caching && count($this->_plugins['outputfilter']) == 0) {
            if ($this->_is_compiled($resource_name, $_smarty_compile_path)
                    || $this->_compile_resource($resource_name, $_smarty_compile_path))
            {
                include($_smarty_compile_path);
            }
        } else {
            ob_start();
            if ($this->_is_compiled($resource_name, $_smarty_compile_path)
                    || $this->_compile_resource($resource_name, $_smarty_compile_path))
            {
                include($_smarty_compile_path);
            }
            $_smarty_results = ob_get_contents();
            ob_end_clean();

            foreach ((array)$this->_plugins['outputfilter'] as $_output_filter) {
                $_smarty_results = call_user_func_array($_output_filter[0], array($_smarty_results, &$this));
            }
        }

        if ($this->caching) {
            $_params = array('tpl_file' => $resource_name,
                        'cache_id' => $cache_id,
                        'compile_id' => $compile_id,
                        'results' => $_smarty_results);
            require_once(SMARTY_CORE_DIR . 'core.write_cache_file.php');
            smarty_core_write_cache_file($_params, $this);
            require_once(SMARTY_CORE_DIR . 'core.process_cached_inserts.php');
            $_smarty_results = smarty_core_process_cached_inserts($_params, $this);

            if ($this->_cache_serials) {
                // strip nocache-tags from output
                $_smarty_results = preg_replace('!(\{/?nocache\:[0-9a-f]{32}#\d+\})!s'
                                                ,''
                                                ,$_smarty_results);
            }
            // restore initial cache_info
            $this->_cache_info = array_pop($_cache_info);
        }
        $this->_cache_including = $_cache_including;

        if ($display) {
            if (isset($_smarty_results)) { echo $_smarty_results; }
            if ($this->debugging) {
                // capture time for debugging info
                $_params = array();
                require_once(SMARTY_CORE_DIR . 'core.get_microtime.php');
                $this->_smarty_debug_info[$_included_tpls_idx]['exec_time'] = (smarty_core_get_microtime($_params, $this) - $_debug_start_time);
                require_once(SMARTY_CORE_DIR . 'core.display_debug_console.php');
                echo smarty_core_display_debug_console($_params, $this);
            }
            error_reporting($_smarty_old_error_level);
            return;
        } else {
            error_reporting($_smarty_old_error_level);
            if (isset($_smarty_results)) { return $_smarty_results; }
        }
    }
& get_config_vars ( name = null)

Returns an array containing config variables

Parámetros:
string$name
string$type
Devuelve:
array

Definición en la línea 1074 del archivo Smarty.class.php.

    {
        if(!isset($name) && is_array($this->_config[0])) {
            return $this->_config[0]['vars'];
        } else if(isset($this->_config[0]['vars'][$name])) {
            return $this->_config[0]['vars'][$name];
        } else {
            // var non-existant, return valid reference
            $_tmp = null;
            return $_tmp;
        }
    }
& get_registered_object ( name)

return a reference to a registered object

Parámetros:
string$name
Devuelve:
object

Definición en la línea 1333 del archivo Smarty.class.php.

                                           {
        if (!isset($this->_reg_objects[$name]))
        $this->_trigger_fatal_error("'$name' is not a registered object");

        if (!is_object($this->_reg_objects[$name][0]))
        $this->_trigger_fatal_error("registered '$name' is not an object");

        return $this->_reg_objects[$name][0];
    }
& get_template_vars ( name = null)

Returns an array containing template variables

Parámetros:
string$name
string$type
Devuelve:
array

Definición en la línea 1054 del archivo Smarty.class.php.

    {
        if(!isset($name)) {
            return $this->_tpl_vars;
        } elseif(isset($this->_tpl_vars[$name])) {
            return $this->_tpl_vars[$name];
        } else {
            // var non-existant, return valid reference
            $_tmp = null;
            return $_tmp;   
        }
    }
is_cached ( tpl_file,
cache_id = null,
compile_id = null 
)

test to see if valid cache exists for this template

Parámetros:
string$tpl_filename of template file
string$cache_id
string$compile_id
Devuelve:
string|false results of _read_cache_file()

Definición en la línea 984 del archivo Smarty.class.php.

    {
        if (!$this->caching)
            return false;

        if (!isset($compile_id))
            $compile_id = $this->compile_id;

        $_params = array(
            'tpl_file' => $tpl_file,
            'cache_id' => $cache_id,
            'compile_id' => $compile_id
        );
        require_once(SMARTY_CORE_DIR . 'core.read_cache_file.php');
        return smarty_core_read_cache_file($_params, $this);
    }
load_filter ( type,
name 
)

load a filter of specified type and name

Parámetros:
string$typefilter type
string$namefilter name

Definición en la línea 912 del archivo Smarty.class.php.

    {
        switch ($type) {
            case 'output':
                $_params = array('plugins' => array(array($type . 'filter', $name, null, null, false)));
                require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
                smarty_core_load_plugins($_params, $this);
                break;

            case 'pre':
            case 'post':
                if (!isset($this->_plugins[$type . 'filter'][$name]))
                    $this->_plugins[$type . 'filter'][$name] = false;
                break;
        }
    }
register_block ( block,
block_impl,
cacheable = true,
cache_attrs = null 
)

Registers block function to be used in templates

Parámetros:
string$blockname of template block
string$block_implPHP function to register

Definición en la línea 741 del archivo Smarty.class.php.

    {
        $this->_plugins['block'][$block] =
            array($block_impl, null, null, false, $cacheable, $cache_attrs);
    }
register_compiler_function ( function,
function_impl,
cacheable = true 
)

Registers compiler function

Parámetros:
string$functionname of template function
string$function_implname of PHP function to register

Definición en la línea 763 del archivo Smarty.class.php.

    {
        $this->_plugins['compiler'][$function] =
            array($function_impl, null, null, false, $cacheable);
    }
register_function ( function,
function_impl,
cacheable = true,
cache_attrs = null 
)

Registers custom function to be used in templates

Parámetros:
string$functionthe name of the template function
string$function_implthe name of the PHP function to register

Definición en la línea 690 del archivo Smarty.class.php.

    {
        $this->_plugins['function'][$function] =
            array($function_impl, null, null, false, $cacheable, $cache_attrs);

    }
register_modifier ( modifier,
modifier_impl 
)

Registers modifier to be used in templates

Parámetros:
string$modifiername of template modifier
string$modifier_implname of PHP function to register

Definición en la línea 785 del archivo Smarty.class.php.

    {
        $this->_plugins['modifier'][$modifier] =
            array($modifier_impl, null, null, false);
    }
register_object ( object,
&$  object_impl,
allowed = array(),
smarty_args = true,
block_methods = array() 
)

Registers object to be used in templates

Parámetros:
string$objectname of template object
object&$object_implthe referenced PHP object to register
null | array$allowedlist of allowed methods (empty = all)
boolean$smarty_argssmarty argument format, else traditional
null | array$block_functslist of methods that are block format

Definición en la línea 716 del archivo Smarty.class.php.

    {
        settype($allowed, 'array');
        settype($smarty_args, 'boolean');
        $this->_reg_objects[$object] =
            array(&$object_impl, $allowed, $smarty_args, $block_methods);
    }
register_outputfilter ( function)

Registers an output filter function to apply to a template output

Parámetros:
string$functionname of PHP function

Definición en la línea 889 del archivo Smarty.class.php.

    {
    $_name = (is_array($function)) ? $function[1] : $function;
        $this->_plugins['outputfilter'][$_name]
            = array($function, null, null, false);
    }
register_postfilter ( function)

Registers a postfilter function to apply to a compiled template after compilation

Parámetros:
string$functionname of PHP function to register

Definición en la línea 866 del archivo Smarty.class.php.

    {
    $_name = (is_array($function)) ? $function[1] : $function;
        $this->_plugins['postfilter'][$_name]
            = array($function, null, null, false);
    }
register_prefilter ( function)

Registers a prefilter function to apply to a template before compiling

Parámetros:
string$functionname of PHP function to register

Definición en la línea 843 del archivo Smarty.class.php.

    {
    $_name = (is_array($function)) ? $function[1] : $function;
        $this->_plugins['prefilter'][$_name]
            = array($function, null, null, false);
    }
register_resource ( type,
functions 
)

Registers a resource to fetch a template

Parámetros:
string$typename of resource
array$functionsarray of functions to handle resource

Definición en la línea 807 del archivo Smarty.class.php.

    {
        if (count($functions)==4) {
            $this->_plugins['resource'][$type] =
                array($functions, false);

        } elseif (count($functions)==5) {
            $this->_plugins['resource'][$type] =
                array(array(array(&$functions[0], $functions[1])
                            ,array(&$functions[0], $functions[2])
                            ,array(&$functions[0], $functions[3])
                            ,array(&$functions[0], $functions[4]))
                      ,false);

        } else {
            $this->trigger_error("malformed function-list for '$type' in register_resource");

        }
    }
Smarty ( )

#@- The class constructor.

Definición en la línea 568 del archivo Smarty.class.php.

    {
      $this->assign('SCRIPT_NAME', isset($_SERVER['SCRIPT_NAME']) ? $_SERVER['SCRIPT_NAME']
                    : @$GLOBALS['HTTP_SERVER_VARS']['SCRIPT_NAME']);
    }
template_exists ( tpl_file)

Checks whether requested template exists.

Parámetros:
string$tpl_file
Devuelve:
boolean

Definición en la línea 1041 del archivo Smarty.class.php.

    {
        $_params = array('resource_name' => $tpl_file, 'quiet'=>true, 'get_source'=>false);
        return $this->_fetch_resource_info($_params);
    }
trigger_error ( error_msg,
error_type = E_USER_WARNING 
)

trigger Smarty error

Parámetros:
string$error_msg
integer$error_type

Definición en la línea 1093 del archivo Smarty.class.php.

    {
        trigger_error("Smarty error: $error_msg", $error_type);
    }
unregister_block ( block)

Unregisters block function

Parámetros:
string$blockname of template function

Definición en la línea 752 del archivo Smarty.class.php.

    {
        unset($this->_plugins['block'][$block]);
    }
unregister_compiler_function ( function)

Unregisters compiler function

Parámetros:
string$functionname of template function

Definición en la línea 774 del archivo Smarty.class.php.

    {
        unset($this->_plugins['compiler'][$function]);
    }
unregister_function ( function)

Unregisters custom function

Parámetros:
string$functionname of template function

Definición en la línea 702 del archivo Smarty.class.php.

    {
        unset($this->_plugins['function'][$function]);
    }
unregister_modifier ( modifier)

Unregisters modifier

Parámetros:
string$modifiername of template modifier

Definición en la línea 796 del archivo Smarty.class.php.

    {
        unset($this->_plugins['modifier'][$modifier]);
    }
unregister_object ( object)

Unregisters object

Parámetros:
string$objectname of template object

Definición en la línea 729 del archivo Smarty.class.php.

    {
        unset($this->_reg_objects[$object]);
    }
unregister_outputfilter ( function)

Unregisters an outputfilter function

Parámetros:
string$functionname of PHP function

Definición en la línea 901 del archivo Smarty.class.php.

    {
        unset($this->_plugins['outputfilter'][$function]);
    }
unregister_postfilter ( function)

Unregisters a postfilter function

Parámetros:
string$functionname of PHP function

Definición en la línea 878 del archivo Smarty.class.php.

    {
        unset($this->_plugins['postfilter'][$function]);
    }
unregister_prefilter ( function)

Unregisters a prefilter function

Parámetros:
string$functionname of PHP function

Definición en la línea 855 del archivo Smarty.class.php.

    {
        unset($this->_plugins['prefilter'][$function]);
    }
unregister_resource ( type)

Unregisters a resource

Parámetros:
string$typename of resource

Definición en la línea 832 del archivo Smarty.class.php.

    {
        unset($this->_plugins['resource'][$type]);
    }

Documentación de los campos

$_cache_include = null

Reimplementado en Smarty_Compiler.

Definición en la línea 554 del archivo Smarty.class.php.

$_cache_including = false

Definición en la línea 562 del archivo Smarty.class.php.

$_cache_info = array()

Definición en la línea 502 del archivo Smarty.class.php.

$_cache_serials = array()

Definición en la línea 547 del archivo Smarty.class.php.

$_compile_id = null

Definición en la línea 481 del archivo Smarty.class.php.

$_conf_obj = null

Definición en la línea 446 del archivo Smarty.class.php.

$_config = array(array('vars' => array(), 'files' => array()))

Definición en la línea 453 del archivo Smarty.class.php.

$_dir_perms = 0771

Definición en la línea 516 del archivo Smarty.class.php.

$_file_perms = 0644

Definición en la línea 509 del archivo Smarty.class.php.

$_foreach = array()

Definición en la línea 432 del archivo Smarty.class.php.

$_inclusion_depth = 0

Definición en la línea 474 del archivo Smarty.class.php.

$_plugins
Valor inicial:
 array(
                                       'modifier'      => array(),
                                       'function'      => array(),
                                       'block'         => array(),
                                       'compiler'      => array(),
                                       'prefilter'     => array(),
                                       'postfilter'    => array(),
                                       'outputfilter'  => array(),
                                       'resource'      => array(),
                                       'insert'        => array())

Definición en la línea 530 del archivo Smarty.class.php.

$_reg_objects = array()

Definición en la línea 523 del archivo Smarty.class.php.

$_sections = array()

Definición en la línea 425 del archivo Smarty.class.php.

$_smarty_debug_id = 'SMARTY_DEBUG'

Definición en la línea 488 del archivo Smarty.class.php.

$_smarty_debug_info = array()

Definición en la línea 495 del archivo Smarty.class.php.

$_smarty_md5 = 'f8d698aea36fcbead2b9d5359ffca76f'

Definición en la línea 460 del archivo Smarty.class.php.

$_smarty_vars = null

Definición en la línea 418 del archivo Smarty.class.php.

$_tag_stack = array()

Definición en la línea 439 del archivo Smarty.class.php.

$_tpl_vars = array()

Definición en la línea 411 del archivo Smarty.class.php.

$_version = '2.6.14'

Definición en la línea 467 del archivo Smarty.class.php.

$autoload_filters = array()

Definición en la línea 338 del archivo Smarty.class.php.

$cache_dir = 'cache'

Definición en la línea 167 del archivo Smarty.class.php.

$cache_handler_func = null

Definición en la línea 331 del archivo Smarty.class.php.

$cache_lifetime = 3600

Definición en la línea 178 del archivo Smarty.class.php.

$cache_modified_check = false

Definición en la línea 188 del archivo Smarty.class.php.

$caching = 0

Definición en la línea 160 del archivo Smarty.class.php.

$compile_check = true

Definición en la línea 141 del archivo Smarty.class.php.

$compile_dir = 'templates_c'

Definición en la línea 82 del archivo Smarty.class.php.

$compile_id = null

Definición en la línea 291 del archivo Smarty.class.php.

$compiler_class = 'Smarty_Compiler'

Definición en la línea 392 del archivo Smarty.class.php.

$compiler_file = 'Smarty_Compiler.class.php'

Definición en la línea 385 del archivo Smarty.class.php.

$config_booleanize = true

This tells whether or not to automatically booleanize config file variables. If enabled, then the strings "on", "true", and "yes" are treated as boolean true, and "off", "false" and "no" are treated as boolean false.

Definición en la línea 354 del archivo Smarty.class.php.

$config_class = 'Config_File'

Definición en la línea 399 del archivo Smarty.class.php.

$config_dir = 'configs'

Definición en la línea 89 del archivo Smarty.class.php.

$config_fix_newlines = true

This tells whether or not automatically fix newlines in config files. It basically converts (mac) or
(dos) to

Definición en la línea 368 del archivo Smarty.class.php.

$config_overwrite = true

This tells if config file vars of the same name overwrite each other or not. if disabled, same name variables are accumulated in an array.

Definición en la línea 347 del archivo Smarty.class.php.

$config_read_hidden = false

This tells whether hidden sections [.foobar] are readable from the tempalates or not. Normally you would never allow this since that is the point behind hidden sections: the application can access them, but the templates cannot.

Definición en la línea 362 del archivo Smarty.class.php.

$debug_tpl = ''

Definición en la línea 120 del archivo Smarty.class.php.

$debugging = false

Definición en la línea 105 del archivo Smarty.class.php.

$debugging_ctrl = 'NONE'

Definición en la línea 131 del archivo Smarty.class.php.

$default_modifiers = array()

Definición en la línea 310 del archivo Smarty.class.php.

$default_resource_type = 'file'

Definición en la línea 324 del archivo Smarty.class.php.

$default_template_handler_func = ''

Definición en la línea 377 del archivo Smarty.class.php.

$error_reporting = null

Definición en la línea 112 del archivo Smarty.class.php.

$force_compile = false

Definición en la línea 149 del archivo Smarty.class.php.

$left_delimiter = '{'

Definición en la línea 255 del archivo Smarty.class.php.

$php_handling = SMARTY_PHP_PASSTHRU

Definición en la línea 202 del archivo Smarty.class.php.

$plugins_dir = array('plugins')

Definición en la línea 96 del archivo Smarty.class.php.

$request_use_auto_globals = true

Definición en la línea 281 del archivo Smarty.class.php.

$request_vars_order = 'EGPCS'

Definición en la línea 271 del archivo Smarty.class.php.

$right_delimiter = '}'

Definición en la línea 262 del archivo Smarty.class.php.

$secure_dir = array()

Definición en la línea 221 del archivo Smarty.class.php.

$security = false

Definición en la línea 212 del archivo Smarty.class.php.

$security_settings
Valor inicial:
 array(
                                    'PHP_HANDLING'    => false,
                                    'IF_FUNCS'        => array('array', 'list',
                                                               'isset', 'empty',
                                                               'count', 'sizeof',
                                                               'in_array', 'is_array',
                                                               'true', 'false', 'null'),
                                    'INCLUDE_ANY'     => false,
                                    'PHP_TAGS'        => false,
                                    'MODIFIER_FUNCS'  => array('count'),
                                    'ALLOW_CONSTANTS'  => false
                                   )

Definición en la línea 229 del archivo Smarty.class.php.

$template_dir = 'templates'

Definición en la línea 75 del archivo Smarty.class.php.

$trusted_dir = array()

Definición en la línea 248 del archivo Smarty.class.php.

$use_sub_dirs = false

Definición en la línea 301 del archivo Smarty.class.php.


La documentación para esta clase fue generada a partir del siguiente fichero: