Version 1.14a

onyx2/modules/templates/smarty/sysplugins/smarty_internal_cacher_inlinecode.php

@@ -0,0 +1,93 @@
+<?php
+
+/**
+* Smarty Internal Plugin Cacher InlineCode
+* 
+* Process nocached code.
+* Version to inject nocache code directly into cache file
+* if caching is disabled at render time the code is being evaluated
+* 
+* @package Smarty
+* @subpackage Cacher
+* @author Uwe Tews 
+*/
+
+/**
+* Smarty Internal Plugin Cacher InlineCode Class
+*/
+class Smarty_Internal_Cacher_InlineCode {
+    function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+
+    /**
+    * Inject inline code for nocache template sections
+    * 
+    * This method gets the content of each template element from the parser.
+    * If the content is compiled code and it should be not cached the code is injected
+    * into the rendered output.
+    * 
+    * @param string $content content of template element
+    * @param object $compiler intance of compiler class
+    * @param boolean $tag_nocache true if the parser detected a nocache situation
+    * @param boolean $is_code true if content is compiled code
+    * @return string content
+    */
+    public function processNocacheCode ($content, $compiler, $is_code)
+    { 
+        // If the template is not evaluated and we have a nocache section and or a nocache tag
+        if ($is_code) {
+            // generate replacement code
+            if (!$compiler->template->isEvaluated() && $compiler->template->caching &&
+                    ($compiler->nocache || $compiler->tag_nocache)) {
+                $compiler->tag_nocache = false;
+                $_output = str_replace("'", "\'", $content);
+                $_output = '<?php  echo \'' . $_output . '\';?>';
+            } else {
+                $_output = $content;
+            } 
+        } else {
+            $_output = $content;
+        } 
+        // if compiled code shall be grabbed
+        if ($compiler->template->extract_code == false) {
+            // return output
+            return $_output;
+        } else {
+            // store code in extract buffer
+            $compiler->template->extracted_compiled_code .= $_output;
+            return '';
+        } 
+    } 
+
+    /**
+    * Initialize cacher
+    * 
+    * Is a noop in current implementation
+    * 
+    * @param object $compiler intance of compiler class
+    */
+    public function initCacher ($compiler)
+    {
+        return;
+    } 
+
+    /**
+    * Close cacher
+    * 
+    * Hook to perform any post processing on the final compiled template
+    * Is a noop in current implementation
+    * 
+    * @param object $compiler intance of compiler class
+    * @param string $template_code complete compiled template
+    * @return string compiled template output
+    */
+    public function closeCacher ($compiler, $template_code)
+    {
+        return $template_code;
+    } 
+
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_cacheresource_file.php

@@ -0,0 +1,180 @@
+<?php
+
+/**
+* Smarty Internal Plugin CacheResource File
+* 
+* Implements the file system as resource for the HTML cache
+* Version ussing nocache inserts
+* 
+* @package Smarty
+* @subpackage Cacher
+* @author Uwe Tews 
+*/
+
+/**
+* This class does contain all necessary methods for the HTML cache on file system
+*/
+class Smarty_Internal_CacheResource_File {
+    function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    /**
+    * Returns the filepath of the cached template output
+    * 
+    * @param object $template current template
+    * @return string the cache filepath
+    */
+    public function getCachedFilepath($template)
+    {
+        return $this->buildCachedFilepath ($template->resource_name, $template->cache_id, $template->compile_id);
+    } 
+
+    /**
+    * Returns the timpestamp of the cached template output
+    * 
+    * @param object $template current template
+    * @return integer |booelan the template timestamp or false if the file does not exist
+    */
+    public function getCachedTimestamp($template)
+    {
+        return ($template->getCachedFilepath() && file_exists($template->getCachedFilepath())) ? filemtime($template->getCachedFilepath()) : false ;
+    } 
+
+    /**
+    * Returns the cached template output
+    * 
+    * @param object $template current template
+    * @return string |booelan the template content or false if the file does not exist
+    */
+    public function getCachedContents($template)
+    {
+        ob_start();
+        $_smarty_tpl = $template;
+        include $template->getCachedFilepath();
+        return ob_get_clean();
+    } 
+
+    /**
+    * Writes the rendered template output to cache file
+    * 
+    * @param object $template current template
+    * @return boolean status
+    */
+    public function writeCachedContent($template, $content)
+    {
+        if (!$template->isEvaluated()) {
+            return Smarty_Internal_Write_File::writeFile($template->getCachedFilepath(), $content);
+        } else {
+            return false;
+        } 
+    } 
+
+    /**
+    * Empty cache folder
+    * 
+    * @param integer $exp_time expiration time
+    * @return integer number of cache files deleted
+    */
+    public function clearAll($exp_time = null)
+    {
+        return $this->clear(null, null, null, $exp_time);
+    } 
+    /**
+    * Empty cache for a specific template
+    * 
+    * @param string $resource_name template name
+    * @param string $cache_id cache id
+    * @param string $compile_id compile id
+    * @param integer $exp_time expiration time
+    * @return integer number of cache files deleted
+    */
+    public function clear($resource_name, $cache_id, $compile_id, $exp_time)
+    {
+        $_dir_sep = $this->smarty->use_sub_dirs ? DS : '^';
+        if (isset($resource_name)) {
+            $_resource_part = (string)abs(crc32($resource_name)) . '.' . $resource_name . $this->smarty->php_ext;
+        } else {
+            $_resource_part = null;
+        } 
+        $_dir = $this->smarty->cache_dir;
+        if (strpos('/\\', substr($_dir, -1)) === false) {
+            $_dir .= DS;
+        } 
+        if ($this->smarty->use_sub_dirs && isset($cache_id)) {
+            $_dir .= str_replace('|', $_dir_sep, $cache_id) . $_dir_sep;
+        } 
+        $_compile_pos = $this->smarty->use_sub_dirs ? 5 : 2;
+        $_count = 0;
+        $_cacheDirs = new RecursiveDirectoryIterator($_dir);
+        $_cache = new RecursiveIteratorIterator($_cacheDirs, RecursiveIteratorIterator::CHILD_FIRST);
+        foreach ($_cache as $_file) {
+            if (strpos($_file, '.svn') !== false) continue;
+            if ($_file->isDir()) {
+                if (!$_cache->isDot()) {
+                    // delete folder if empty
+                    @rmdir($_file->getPathname());
+                } 
+            } else {
+                $_parts = explode($_dir_sep, $_file);
+                $_parts_count = count($_parts);
+                $_parts_compile_pos = $_parts_count - $_compile_pos;
+                if ($_parts_compile_pos < 0) {
+                    $_parts_compile_pos = 0;
+                } 
+                if ((substr_compare((string)$_file, $_dir, 0, strlen($_dir)) == 0 &&
+                            (!isset($resource_name) || $_parts[$_parts_count-1] == $_resource_part) &&
+                            (!isset($compile_id) || $_parts[$_parts_compile_pos] == $compile_id)) ||
+                        (isset($resource_name) && (string)$_file == $_dir . $_resource_part)) {
+                    if (isset($exp_time)) {
+                        if (time() - @filemtime($_file) >= $exp_time) {
+                            $_count += unlink((string) $_file) ? 1 : 0;
+                        } 
+                    } else {
+                        $_count += unlink((string) $_file) ? 1 : 0;
+                    } 
+                } 
+            } 
+        } 
+        return $_count;
+    } 
+    /**
+    * Get system filepath to cached file
+    * 
+    * @param string $resource_name template name
+    * @param string $cache_id cache id
+    * @param string $compile_id compile id
+    * @return string filepath of cache file
+    */
+    private function buildCachedFilepath ($resource_name, $cache_id, $compile_id)
+    {
+        $_files = explode('|', $resource_name);
+        $_filepath = (string)abs(crc32($resource_name)); 
+        // if use_sub_dirs, break file into directories
+        if ($this->smarty->use_sub_dirs) {
+            $_filepath = substr($_filepath, 0, 2) . DS
+             . substr($_filepath, 2, 2) . DS
+             . substr($_filepath, 4, 2) . DS
+             . $_filepath;
+        } 
+        $_compile_dir_sep = $this->smarty->use_sub_dirs ? DS : '^';
+        if (isset($cache_id)) {
+            $_cache_id = str_replace('|', $_compile_dir_sep, $cache_id) . $_compile_dir_sep;
+        } else {
+            $_cache_id = '';
+        } 
+        if (isset($compile_id)) {
+            $_compile_id = $compile_id . $_compile_dir_sep;
+        } else {
+            $_compile_id = '';
+        } 
+        $_cache_dir = $this->smarty->cache_dir;
+        if (strpos('/\\', substr($_cache_dir, -1)) === false) {
+            $_cache_dir .= DS;
+        } 
+
+        return $_cache_dir . $_cache_id . $_compile_id . $_filepath . '.' . basename($_files[count($_files)-1]) . $this->smarty->php_ext;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_append.php

@@ -0,0 +1,61 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Append
+* 
+* Compiles the {append} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Append Class
+*/
+class Smarty_Internal_Compile_Append extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {append} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('var', 'value');
+        $this->optional_attributes = array('scope', 'nocache', 'index');
+
+        $_nocache = 'null';
+        $_scope = 'null'; 
+        // check for nocache attribute before _get_attributes because
+        // it shall not controll caching of the compiled code, but is a parameter
+        if (isset($args['nocache'])) {
+            if ($args['nocache'] == 'true') {
+                $_nocache = 'true';
+                $_nocache_boolean = true;
+            } 
+            unset($args['nocache']);
+        } 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        if (isset($_attr['scope'])) {
+            if ($_attr['scope'] == '\'parent\'') {
+                $_scope = SMARTY_PARENT_SCOPE;
+            } elseif ($_attr['scope'] == '\'root\'') {
+                $_scope = SMARTY_ROOT_SCOPE;
+           } elseif ($_attr['scope'] == '\'global\'') {
+                $_scope = SMARTY_GLOBAL_SCOPE;
+            } 
+        } 
+        // compiled output
+        if (isset($_attr['index'])) {
+            return "<?php \$_smarty_tpl->append($_attr[var],array($_attr[index] => $_attr[value]),true,$_nocache,$_scope);?>";
+        } else {
+            return "<?php \$_smarty_tpl->append($_attr[var],$_attr[value],false,$_nocache,$_scope);?>";
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_assign.php

@@ -0,0 +1,69 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Assign
+* 
+* Compiles the {assign} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Assign Class
+*/
+class Smarty_Internal_Compile_Assign extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {assign} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('var', 'value');
+        $this->optional_attributes = array('scope', 'nocache', 'index');
+
+        $_nocache = 'null';
+        $_scope = 'null'; 
+        // check for nocache attribute before _get_attributes because
+        // it shall not controll caching of the compiled code, but is a parameter
+        if (isset($args['nocache'])) {
+            if ($args['nocache'] == 'true') {
+                $_nocache = 'true';
+                $_nocache_boolean = true;
+            } 
+            unset($args['nocache']);
+        } 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        if (isset($_attr['scope'])) {
+            if ($_attr['scope'] == '\'parent\'') {
+                $_scope = SMARTY_PARENT_SCOPE;
+            } elseif ($_attr['scope'] == '\'root\'') {
+                $_scope = SMARTY_ROOT_SCOPE;
+           } elseif ($_attr['scope'] == '\'global\'') {
+                $_scope = SMARTY_GLOBAL_SCOPE;
+            } 
+        } 
+
+        if (isset($_attr['index'])) {
+            $_index = $_attr['index'];
+        } 
+        // compiled output
+        if (isset($_attr['index'])) {
+            if ($_attr['index'] == '') {
+                return "<?php \$_smarty_tpl->append($_attr[var],$_attr[value],false,$_nocache,$_scope);?>";
+            } else {
+                return "<?php \$_tmp$_attr[index] = $_attr[value]; \$_smarty_tpl->append($_attr[var],\$_tmp,true,$_nocache,$_scope); unset (\$_tmp);?>";
+            } 
+        } else {
+            return "<?php \$_smarty_tpl->assign($_attr[var],$_attr[value],$_nocache,$_scope);?>";
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_block.php

@@ -0,0 +1,84 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Block
+* 
+* Compiles the {block}{/block} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Block Class
+*/
+class Smarty_Internal_Compile_Block extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {block} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return boolean true
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('name');
+        $this->optional_attributes = array('assign'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        $save = array($_attr, $compiler->template->extracted_compiled_code, $compiler->template->extract_code); 
+        $this->_open_tag('block', $save);
+        $compiler->template->extract_code = true;
+        $compiler->template->extracted_compiled_code = '';
+        $compiler->template->has_code = false; 
+        return true;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile BlockClose Class
+*/
+class Smarty_Internal_Compile_Blockclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/block} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->smarty = $compiler->smarty;
+        $this->compiler->has_code = true; 
+        // turn off block code extraction
+        $compiler->template->extract_code = false; 
+        // check and get attributes
+        $this->optional_attributes = array('name');
+        $_attr = $this->_get_attributes($args);
+        $saved_data = $this->_close_tag(array('block')); 
+        // if name does match to opening tag
+        if (isset($_attr['name']) && $saved_data[0]['name'] != $_attr['name']) {
+            $this->compiler->trigger_template_error('mismatching name attributes "' . $saved_data[0]['name'] . '" and "' . $_attr['name'] . '"');
+        } 
+        $_name = trim($saved_data[0]['name'], "\"'");
+        if (isset($this->smarty->block_data[$_name])) {
+            if (strpos($this->smarty->block_data[$_name]['compiled'], '%%%%SMARTY_PARENT%%%%') !== false) {
+                $_output = str_replace('%%%%SMARTY_PARENT%%%%', $compiler->template->extracted_compiled_code, $this->smarty->block_data[$_name]['compiled']);
+            } elseif ($this->smarty->block_data[$_name]['mode'] == 'prepend') {
+                $_output = $this->smarty->block_data[$_name]['compiled'] . $compiler->template->extracted_compiled_code;
+            } elseif ($this->smarty->block_data[$_name]['mode'] == 'append') {
+                $_output = $compiler->template->extracted_compiled_code . $this->smarty->block_data[$_name]['compiled'];
+            } elseif (!empty($this->smarty->block_data[$_name])) {
+                $_output = $this->smarty->block_data[$_name]['compiled'];
+            } 
+        } else {
+            $_output = $compiler->template->extracted_compiled_code;
+        } 
+        $compiler->template->extracted_compiled_code = $saved_data[1];
+        $compiler->template->extract_code = $saved_data[2];
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_block_plugin.php

@@ -0,0 +1,64 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Block Plugin
+* 
+* Compiles code for the execution of block plugin
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Block Plugin Class
+*/
+class Smarty_Internal_Compile_Block_Plugin extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the execution of block plugin
+    * 
+    * @param array $args array with attributes from parser
+    * @param string $tag name of block function
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler, $tag)
+    {
+        $this->compiler = $compiler;
+        if (strlen($tag) < 6 || substr_compare($tag, 'close', -5, 5) != 0) {
+            // opening tag of block plugin
+            $this->required_attributes = array();
+            $this->optional_attributes = array('_any'); 
+            // check and get attributes
+            $_attr = $this->_get_attributes($args); 
+            // convert attributes into parameter array string
+            $_paramsArray = array();
+            foreach ($_attr as $_key => $_value) {
+                $_paramsArray[] = "'$_key'=>$_value";
+            } 
+            $_params = 'array(' . implode(",", $_paramsArray) . ')';
+
+            $this->_open_tag($tag, array($_params, $this->compiler->nocache)); 
+            // not cachable?
+            if (isset($this->compiler->smarty->registered_plugins[$tag]) && !$this->compiler->smarty->registered_plugins[$tag][2]) {
+                $this->compiler->nocache = true;
+            } 
+			// maybe nocache because of nocache variables
+			$this->compiler->nocache = $this->compiler->nocache | $this->compiler->tag_nocache;
+			// compile code
+            $output = '<?php $_block_repeat=true; $_smarty_tpl->smarty->plugin_handler->' . $tag . '(array(' . $_params . ', null, $_smarty_tpl->smarty, &$_block_repeat, $_smarty_tpl),\'block\');while ($_block_repeat) { ob_start();?>';
+        } else {
+			// must endblock be nocache?
+			if ($this->compiler->nocache) {
+                 $this->compiler->tag_nocache = true;
+            }
+            // closing tag of block plugin, restore nocache
+            list($_params, $this->compiler->nocache) = $this->_close_tag(substr($tag, 0, -5)); 
+            // This tag does create output
+            $this->compiler->has_output = true; 
+            // compile code
+            $output = '<?php $_block_content = ob_get_clean(); $_block_repeat=false; echo $_smarty_tpl->smarty->plugin_handler->' . substr($tag, 0, -5) . '(array(' . $_params . ', $_block_content, $_smarty_tpl->smarty, &$_block_repeat, $_smarty_tpl),\'block\'); }?>';
+        } 
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_capture.php

@@ -0,0 +1,72 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Capture
+* 
+* Compiles the {capture} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Capture Class
+*/
+class Smarty_Internal_Compile_Capture extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {capture} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->optional_attributes = array('name', 'assign', 'append'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $buffer = isset($_attr['name']) ? $_attr['name'] : "'default'";
+        $assign = isset($_attr['assign']) ? $_attr['assign'] : null;
+        $append = isset($_attr['append']) ? $_attr['append'] : null;
+
+        $this->compiler->_capture_stack[] = array($buffer, $assign, $append);
+
+        $_output = "<?php ob_start(); ?>";
+
+        return $_output;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Captureclose Class
+*/
+class Smarty_Internal_Compile_CaptureClose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/capture} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        list($buffer, $assign, $append) = array_pop($this->compiler->_capture_stack);
+
+        $_output = "<?php ";
+        if (isset($assign)) {
+            $_output .= " \$_smarty_tpl->assign($assign, ob_get_contents());";
+        } 
+        if (isset($append)) {
+            $_output .= " \$_smarty_tpl->append($append, ob_get_contents());";
+        } 
+        $_output .= " \$_smarty_tpl->smarty->_smarty_vars['capture'][$buffer]=ob_get_clean(); ?>";
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_config_load.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Config Load
+* 
+* Compiles the {config load} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Config Load Class
+*/
+class Smarty_Internal_Compile_Config_Load extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {config_load} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('file');
+        $this->optional_attributes = array('section', 'scope'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args); 
+        // save posible attributes
+        $conf_file = $_attr['file'];
+        if (isset($_attr['section'])) {
+            $section = $_attr['section'];
+        } else {
+            $section = 'null';
+        } 
+        $scope = '$_smarty_tpl->smarty';
+        if (isset($_attr['scope'])) {
+            if ($_attr['scope'] == '\'local\'') {
+                $scope = '$_smarty_tpl';
+            } elseif ($_attr['scope'] == '\'parent\'') {
+                $scope = '$_smarty_tpl->parent';
+            } 
+        } 
+
+        // create config object
+        $_output = "<?php  \$_config = new Smarty_Internal_Config($conf_file, \$_smarty_tpl->smarty, \$_smarty_tpl);";
+        $_output .= "\$_config->loadConfigVars($section, $scope); ?>";
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_debug.php

@@ -0,0 +1,34 @@
+<?php 
+/**
+* Smarty Internal Plugin Compile Debug
+*
+* Compiles the {debug} tag 
+* It opens a window the the Smarty Debugging Console
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews
+*/
+/**
+* Smarty Internal Plugin Compile Debug Class
+*/ 
+class Smarty_Internal_Compile_Debug extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {debug} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        // display debug template
+        $_output = "<?php \$_smarty_tpl->smarty->loadPlugin('Smarty_Internal_Debug'); Smarty_Internal_Debug::display_debug(\$_smarty_tpl->smarty); ?>";
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_eval.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Eval
+*
+* Compiles the {eval} tag 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews
+*/
+/**
+* Smarty Internal Plugin Compile Eval Class
+*/ 
+class Smarty_Internal_Compile_Eval extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {eval} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        $this->required_attributes = array('var');
+        $this->optional_attributes = array('assign'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args); 
+        if (isset($_attr['assign'])) {
+              // output will be stored in a smarty variable instead of beind displayed
+            $_assign = $_attr['assign'];
+        }
+  
+        // create template object
+        $_output = "\$_template = new Smarty_Template ('string:'.".$_attr['var'].", \$_smarty_tpl->smarty, \$_smarty_tpl);"; 
+        //was there an assign attribute? 
+        if (isset($_assign)) {
+            $_output .= "\$_smarty_tpl->assign($_assign,\$_smarty_tpl->smarty->fetch(\$_template));";
+        } else {
+            $_output .= "echo \$_smarty_tpl->smarty->fetch(\$_template);";
+        } 
+        return "<?php $_output ?>";
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_extend.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile extend
+* 
+* Compiles the {extend} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile extend Class
+*/
+class Smarty_Internal_Compile_Extend extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {extend} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->smarty =$compiler->smarty;
+        $this->required_attributes = array('file'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        $_smarty_tpl = $compiler->template; 
+        // $include_file = '';
+        eval('$include_file = ' . $_attr['file'] . ';'); 
+        // create template object
+        $_template = new Smarty_Template ($include_file, $this->smarty, $compiler->template); 
+        // save file dependency
+        $compiler->template->properties['file_dependency']['F'.abs(crc32($_template->getTemplateFilepath()))] = array($_template->getTemplateFilepath(), $_template->getTemplateTimestamp());
+        $_old_source = $compiler->template->template_source;
+        if (preg_match_all('/(' . $this->smarty->left_delimiter . 'block(.+?)' . $this->smarty->right_delimiter . ')/', $_old_source, $s, PREG_OFFSET_CAPTURE) !=
+                preg_match_all('/(' . $this->smarty->left_delimiter . '\/block(.*?)' . $this->smarty->right_delimiter . ')/', $_old_source, $c, PREG_OFFSET_CAPTURE)) {
+            $this->compiler->trigger_template_error(" unmatched {block} {/block} pairs");
+        } 
+        $block_count = count($s[0]);
+        for ($i = 0; $i < $block_count; $i++) {
+            $block_content = str_replace($this->smarty->left_delimiter . '$smarty.parent' . $this->smarty->right_delimiter, '%%%%SMARTY_PARENT%%%%',
+                substr($_old_source, $s[0][$i][1] + strlen($s[0][$i][0]), $c[0][$i][1] - $s[0][$i][1] - strlen($s[0][$i][0])));
+            $this->saveBlockData($block_content, $s[0][$i][0]);
+        } 
+        $compiler->template->template_source = $_template->getTemplateSource();
+        $compiler->abort_and_recompile = true;
+        return ' ';
+    } 
+
+    protected function saveBlockData($block_content, $block_tag)
+    {
+        if (0 == preg_match('/(.?)(name=)([^ ]*)/', $block_tag, $_match)) {
+            $this->compiler->trigger_template_error("\"" . $block_tag . "\" missing name attribute");
+        } else {
+            // compile block content
+            $_tpl = $this->smarty->createTemplate('string:' . $block_content);
+            $_tpl->template_filepath = $this->compiler->template->getTemplateFilepath();
+            $_tpl->suppressFileDependency = true;
+            $_compiled_content = $_tpl->getCompiledTemplate();
+            unset($_tpl);
+            $_name = trim($_match[3], "\"'}");
+
+            if (isset($this->smarty->block_data[$_name])) {
+                if (strpos($this->smarty->block_data[$_name]['compiled'], '%%%%SMARTY_PARENT%%%%') !== false) {
+                    $this->smarty->block_data[$_name]['compiled'] =
+                    str_replace('%%%%SMARTY_PARENT%%%%', $_compiled_content, $this->smarty->block_data[$_name]['compiled']);
+                } elseif ($this->smarty->block_data[$_name]['mode'] == 'prepend') {
+                    $this->smarty->block_data[$_name]['compiled'] .= $_compiled_content;
+                } elseif ($this->smarty->block_data[$_name]['mode'] == 'append') {
+                    $this->smarty->block_data[$_name]['compiled'] = $_compiled_content . $this->smarty->block_data[$_name]['compiled'];
+                } 
+            } else {
+                $this->smarty->block_data[$_name]['compiled'] = $_compiled_content;
+            } 
+            if (preg_match('/(.?)(append=true)(.*)/', $block_tag, $_match) != 0) {
+                $this->smarty->block_data[$_name]['mode'] = 'append';
+            } elseif (preg_match('/(.?)(prepend=true)(.*)/', $block_tag, $_match) != 0) {
+                $this->smarty->block_data[$_name]['mode'] = 'prepend';
+            } else {
+                $this->smarty->block_data[$_name]['mode'] = 'replace';
+            } 
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_for.php

@@ -0,0 +1,109 @@
+<?php
+/**
+* Smarty Internal Plugin Compile For
+* 
+* Compiles the {for} {forelse} {/for} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile For Class
+*/
+class Smarty_Internal_Compile_For extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {for} tag
+    * 
+    * Smarty 3 does implement two different sytaxes:
+    * 
+    * - {for $var in $array}
+    * For looping over arrays or iterators
+    * 
+    * - {for $x=0; $x<$y; $x++}
+    * For general loops
+    * 
+    * The parser is gereration different sets of attribute by which this compiler can 
+    * determin which syntax is used.
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // {for $x=0; $x<$y; $x++} syntax
+        $this->required_attributes = array('ifexp', 'start', 'loop', 'varloop'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $this->_open_tag('for', array('for',$this->compiler->nocache));
+		// maybe nocache because of nocache variables
+		$this->compiler->nocache = $this->compiler->nocache | $this->compiler->tag_nocache;
+
+        $output = "<?php ";
+        foreach ($_attr['start'] as $_statement) {
+            $output .= " \$_smarty_tpl->tpl_vars[$_statement[var]] = new Smarty_Variable;";
+            $output .= " \$_smarty_tpl->tpl_vars[$_statement[var]]->value = $_statement[value];\n";
+        } 
+        $output .= "  if ($_attr[ifexp]){ for (\$_foo=true;$_attr[ifexp]; \$_smarty_tpl->tpl_vars[$_attr[varloop]]->value$_attr[loop]){\n";
+        $output .= "?>"; 
+        // return compiled code
+        return $output;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Forelse Class
+*/
+class Smarty_Internal_Compile_Forelse extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {forelse} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('for'));
+        $this->_open_tag('forelse',array('forelse', $this->compiler->nocache));
+        return "<?php }} else { ?>";
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Forclose Class
+*/
+class Smarty_Internal_Compile_Forclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/for} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+		// must endblock be nocache?
+		if ($this->compiler->nocache) {
+               $this->compiler->tag_nocache = true;
+        }
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('for', 'forelse'));
+        if ($_open_tag == 'forelse')
+            return "<?php }  ?>";
+        else
+            return "<?php }} ?>";
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_foreach.php

@@ -0,0 +1,192 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Foreach
+* 
+* Compiles the {foreach} {foreachelse} {/foreach} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Foreach Class
+*/
+class Smarty_Internal_Compile_Foreach extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {foreach} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('from', 'item');
+        $this->optional_attributes = array('name', 'key');
+        $tpl = $compiler->template; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $this->_open_tag('foreach', array('foreach',$this->compiler->nocache));
+		// maybe nocache because of nocache variables
+		$this->compiler->nocache = $this->compiler->nocache | $this->compiler->tag_nocache;
+
+        $from = $_attr['from'];
+        $item = $_attr['item'];
+
+        if (isset($_attr['key'])) {
+            $key = $_attr['key'];
+        } else {
+            $key = null;
+        } 
+
+        if (isset($_attr['name'])) {
+            $name = $_attr['name'];
+            $has_name = true;
+            $SmartyVarName = '$smarty.foreach.' . trim($name,'\'"') . '.';
+        } else {
+            $name = null;
+            $has_name = false;
+        } 
+        $ItemVarName = '$' . trim($item,'\'"') . '@';
+        // evaluates which Smarty variables and properties have to be computed
+        if ($has_name) {
+            $usesSmartyFirst = strpos($tpl->template_source, $SmartyVarName . 'first') !== false;
+            $usesSmartyLast = strpos($tpl->template_source, $SmartyVarName . 'last') !== false;
+            $usesSmartyIndex = strpos($tpl->template_source, $SmartyVarName . 'index') !== false;
+            $usesSmartyIteration = strpos($tpl->template_source, $SmartyVarName . 'iteration') !== false;
+            $usesSmartyShow = strpos($tpl->template_source, $SmartyVarName . 'show') !== false;
+            $usesSmartyTotal = $usesSmartyLast || strpos($tpl->template_source, $SmartyVarName . 'total') !== false;
+        } else {
+            $usesSmartyFirst = false;
+            $usesSmartyLast = false;
+            $usesSmartyTotal = false;
+        }
+
+        $usesPropFirst = $usesSmartyFirst || strpos($tpl->template_source, $ItemVarName . 'first') !== false;
+        $usesPropLast = $usesSmartyLast || strpos($tpl->template_source, $ItemVarName . 'last') !== false;
+        $usesPropIndex = $usesPropFirst || strpos($tpl->template_source, $ItemVarName . 'index') !== false;
+        $usesPropIteration = $usesPropLast || strpos($tpl->template_source, $ItemVarName . 'iteration') !== false;
+        $usesPropShow = strpos($tpl->template_source, $ItemVarName . 'show') !== false;
+        $usesPropTotal = $usesSmartyTotal || $usesPropLast || strpos($tpl->template_source, $ItemVarName . 'total') !== false; 
+        // generate output code
+        $output = "<?php ";
+        $output .= " \$_smarty_tpl->tpl_vars[$item] = new Smarty_Variable;\n";
+        if ($key != null) {
+            $output .= " \$_smarty_tpl->tpl_vars[$key] = new Smarty_Variable;\n";
+        } 
+        $output .= " \$_from = $from; if (!is_array(\$_from) && !is_object(\$_from)) { settype(\$_from, 'array');}\n";
+        if ($usesPropTotal) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->total=count(\$_from);\n";
+        } 
+        if ($usesPropIteration) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->iteration=0;\n";
+        } 
+        if ($usesPropIndex) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->index=-1;\n";
+        } 
+        if ($has_name) {
+            if ($usesSmartyTotal) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['total'] = \$_smarty_tpl->tpl_vars[$item]->total;\n";
+            } 
+            if ($usesSmartyIteration) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['iteration']=0;\n";
+            } 
+            if ($usesSmartyIndex) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['index']=-1;\n";
+            } 
+        } 
+        $output .= "if (count(\$_from) > 0){\n";
+        $output .= "    foreach (\$_from as \$_smarty_tpl->tpl_vars[$item]->key => \$_smarty_tpl->tpl_vars[$item]->value){\n";
+        if ($key != null) {
+            $output .= " \$_smarty_tpl->tpl_vars[$key]->value = \$_smarty_tpl->tpl_vars[$item]->key;\n";
+        } 
+        if ($usesPropIteration) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->iteration++;\n";
+        } 
+        if ($usesPropIndex) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->index++;\n";
+        } 
+        if ($usesPropFirst) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->first = \$_smarty_tpl->tpl_vars[$item]->index === 0;\n";
+        } 
+        if ($usesPropLast) {
+            $output .= " \$_smarty_tpl->tpl_vars[$item]->last = \$_smarty_tpl->tpl_vars[$item]->iteration === \$_smarty_tpl->tpl_vars[$item]->total;\n";
+        } 
+        if ($has_name) {
+            if ($usesSmartyFirst) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['first'] = \$_smarty_tpl->tpl_vars[$item]->first;\n";
+            } 
+            if ($usesSmartyIteration) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['iteration']++;\n";
+            } 
+            if ($usesSmartyIndex) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['index']++;\n";
+            } 
+            if ($usesSmartyLast) {
+                $output .= " \$_smarty_tpl->tpl_vars['smarty']->value['foreach'][$name]['last'] = \$_smarty_tpl->tpl_vars[$item]->last;\n";
+            } 
+        } 
+        $output .= "?>";
+
+        return $output;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Foreachelse Class
+*/ 
+class Smarty_Internal_Compile_Foreachelse extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {foreachelse} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('foreach'));
+        $this->_open_tag('foreachelse',array('foreachelse', $this->compiler->nocache));
+
+        return "<?php }} else { ?>";
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Foreachclose Class
+*/ 
+class Smarty_Internal_Compile_Foreachclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/foreach} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+		// must endblock be nocache?
+		if ($this->compiler->nocache) {
+               $this->compiler->tag_nocache = true;
+        }
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('foreach', 'foreachelse'));
+
+        if ($_open_tag == 'foreachelse')
+            return "<?php } ?>";
+        else
+            return "<?php }} ?>";
+    } 
+}
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_function.php

@@ -0,0 +1,79 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Function
+* 
+* Compiles the {function} {/function} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Function Class
+*/
+class Smarty_Internal_Compile_Function extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {function} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return boolean true
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('name');
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        $save = array($_attr, $compiler->template->extracted_compiled_code, $compiler->template->extract_code);
+        $this->_open_tag('function', $save);
+        $_name = trim($_attr['name'], "'");
+        foreach ($_attr as $_key => $_data) {
+            $compiler->template->properties['function'][$_name]['parameter'][$_key] = $_data;
+        } 
+        // make function known for recursive calls
+        $this->compiler->smarty->template_functions[$_name]['compiled'] = '';
+        $compiler->template->extract_code = true;
+        $compiler->template->extracted_compiled_code = '';
+        $compiler->template->has_code = false;
+        return true;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Functionclose Class
+*/
+class Smarty_Internal_Compile_Functionclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/function} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return boolean true
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->compiler->has_code = false; 
+        // turn off block code extraction
+        $compiler->template->extract_code = false; 
+        // check and get attributes
+        $this->optional_attributes = array('name');
+        $_attr = $this->_get_attributes($args);
+        $saved_data = $this->_close_tag(array('function')); 
+        // if name does match to opening tag
+        if (isset($_attr['name']) && $saved_data[0]['name'] != $_attr['name']) {
+            $this->compiler->trigger_template_error('mismatching name attributes "' . $saved_data[0]['name'] . '" and "' . $_attr['name'] . '"');
+        } 
+        $_name = trim($saved_data[0]['name'], "'");
+        $compiler->template->properties['function'][$_name]['compiled'] = str_replace("\n",'_%n',$compiler->template->extracted_compiled_code);
+        $this->compiler->smarty->template_functions[$_name]['compiled'] = $compiler->template->extracted_compiled_code;
+        $this->compiler->smarty->template_functions[$_name]['parameter'] = $compiler->template->properties['function'][$_name]['parameter'];
+        $compiler->template->extracted_compiled_code = $saved_data[1];
+        $compiler->template->extract_code = $saved_data[2];
+        return true;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_function_call.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Function_Call
+* 
+* Compiles the calls of user defined tags defined by {function}
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Function_Call Class
+*/
+class Smarty_Internal_Compile_Function_Call extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles the calls of user defined tags defined by {function}
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('name');
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args); 
+        // save posible attributes
+        if (isset($_attr['assign'])) {
+            // output will be stored in a smarty variable instead of beind displayed
+            $_assign = $_attr['assign'];
+        } 
+        $_name = trim($_attr['name'], "'"); 
+        // create template object
+        $_output = "<?php \$_template = new Smarty_Template ('string:', \$_smarty_tpl->smarty, \$_smarty_tpl);\n"; 
+        // assign default paramter
+        if (isset($this->smarty->template_functions[$_name]['parameter'])) {
+            // function is already compiled
+            foreach ($this->smarty->template_functions[$_name]['parameter'] as $_key => $_value) {
+                if (!isset($_attr[$_key])) {
+                    $_output .= "\$_template->assign('$_key',$_value);\n";
+                } 
+            } 
+        } 
+        if (isset($compiler->template->properties['function'][$_name]['parameter'])) {
+            // for recursive call during function compilation
+            foreach ($compiler->template->properties['function'][$_name]['parameter'] as $_key => $_value) {
+                if (!isset($_attr[$_key])) {
+                    $_output .= "\$_template->assign('$_key',$_value);\n";
+                } 
+            } 
+        } 
+        // delete {include} standard attributes
+        unset($_attr['name'], $_attr['assign']); 
+        // remaining attributes must be assigned as smarty variable
+        if (!empty($_attr)) {
+            // create variables
+            foreach ($_attr as $_key => $_value) {
+                $_output .= "\$_template->assign('$_key',$_value);\n";
+            } 
+        } 
+        // load compiled function
+        $_output .= "\$_template->compiled_template = \$this->smarty->template_functions['$_name']['compiled'];\n\$_template->mustCompile = false;\n"; 
+        // was there an assign attribute
+        if (isset($_assign)) {
+            $_output .= "\$_smarty_tpl->assign($_assign,\$_smarty_tpl->smarty->fetch(\$_template)); ?>";
+        } else {
+            $_output .= "echo \$_smarty_tpl->smarty->fetch(\$_template); ?>";
+        } 
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_function_plugin.php

@@ -0,0 +1,50 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Function Plugin
+* 
+* Compiles code for the execution of function plugin
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Function Plugin Class
+*/
+class Smarty_Internal_Compile_Function_Plugin extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the execution of function plugin
+    * 
+    * @param array $args array with attributes from parser
+    * @param string $tag name of function
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler, $tag)
+    {
+        $this->compiler = $compiler; 
+        // This tag does create output
+        $this->compiler->has_output = true;
+
+        $this->required_attributes = array();
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        // not cachable?
+        if (isset($this->compiler->smarty->registered_plugins[$tag]) && !$this->compiler->smarty->registered_plugins[$tag][2]) {
+            $this->compiler->tag_nocache = true;        
+        }
+        // convert attributes into parameter array string
+        $_paramsArray = array();
+        foreach ($_attr as $_key => $_value) {
+            $_paramsArray[] = "'$_key'=>$_value";
+        } 
+        $_params = 'array(' . implode(",", $_paramsArray) . ')'; 
+        // compile code
+        $output = '<?php echo $_smarty_tpl->smarty->plugin_handler->' . $tag . '(array(' . $_params . ',$_smarty_tpl->smarty,$_smarty_tpl),\'function\');?>';
+
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_if.php

@@ -0,0 +1,114 @@
+<?php
+/**
+* Smarty Internal Plugin Compile If
+* 
+* Compiles the {if} {else} {elseif} {/if} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile If Class
+*/
+class Smarty_Internal_Compile_If extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {if} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('if condition'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        $this->_open_tag('if',array(1,$compiler->tag_nocache));
+        if (is_array($args['if condition'])) {
+            $_output = "<?php if (!isset(\$_smarty_tpl->tpl_vars[".$args['if condition']['var']."])) \$_smarty_tpl->tpl_vars[".$args['if condition']['var']."] = new Smarty_Variable;";
+            $_output .= "if (\$_smarty_tpl->tpl_vars[".$args['if condition']['var']."]->value = ".$args['if condition']['value']."){?>";
+            return $_output;
+        } else {
+            return '<?php if (' . $args['if condition'] . '){?>';
+        } 
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Else Class
+*/
+class Smarty_Internal_Compile_Else extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {else} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        list($nesting, $compiler->tag_nocache) = $this->_close_tag(array('if', 'elseif'));
+        $this->_open_tag('else',array($nesting,$compiler->tag_nocache));
+
+        return '<?php }else{ ?>';
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile ElseIf Class
+*/
+class Smarty_Internal_Compile_Elseif extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {elseif} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('if condition'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        list($nesting, $compiler->tag_nocache) = $this->_close_tag(array('if', 'elseif'));
+
+        if (empty($this->compiler->prefix_code)) {
+            $this->_open_tag('elseif', array($nesting, $compiler->tag_nocache));
+            return '<?php }elseif(' . $args['if condition'] . '){?>';
+        } else {
+            $tmp = '';
+            foreach ($this->compiler->prefix_code as $code) $tmp .= $code;
+            $this->compiler->prefix_code = array();
+            $this->_open_tag('elseif', array($nesting + 1, $compiler->tag_nocache));
+            return '<?php }else{?>' . $tmp . '<?php if (' . $args['if condition'] . '){?>';
+        } 
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Ifclose Class
+*/
+class Smarty_Internal_Compile_Ifclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/if} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        list($nesting, $compiler->tag_nocache) = $this->_close_tag(array('if', 'else', 'elseif'));
+        $tmp = '';
+        for ($i = 0; $i < $nesting ; $i++) $tmp .= '}';
+        return "<?php $tmp?>";
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_include.php

@@ -0,0 +1,159 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Include
+* 
+* Compiles the {include} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Include Class
+*/
+class Smarty_Internal_Compile_Include extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {include} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('file');
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args); 
+        // save posible attributes
+        $include_file = $_attr['file'];
+        $has_compiled_template = false;
+        if ($compiler->smarty->merge_compiled_includes) {
+            // check if compiled code can be merged (contains no variable part)
+            if (!$compiler->has_variable_string && (substr_count($include_file, '"') == 2 or substr_count($include_file, "'") == 2) and substr_count($include_file, '(') == 0) {
+                eval("\$tmp = $include_file;");
+				if ($this->compiler->template->template_resource != $tmp) {
+                $tpl = $compiler->smarty->createTemplate ($tmp, $compiler->template->cache_id, $compiler->template->compile_id, $compiler->template);
+                if ($tpl->usesCompiler() && $tpl->isExisting()) {
+                    do {
+                        $must_compile = false;
+                        $prop = array();
+                        $compiled_tpl = $tpl->getCompiledTemplate();
+                        preg_match('/(\<\?php \$_smarty_tpl-\>decodeProperties\(\')(.*)(\'.*\?\>)/', $compiled_tpl, $matches);
+                        $compiled_tpl = preg_replace(array('/(\<\?php \$_smarty_tpl-\>decodeProperties\(\')(.*)(\'.*\?\>.*\n)/', '/(\<\?php if\(\!defined\(\'SMARTY_DIR\'\)\))(.*)(\?\>.*\n)/'), '', $compiled_tpl); 
+                        // var_dump($matches, $compiled_tpl);
+                        if (isset($matches[2])) {
+                            $prop = unserialize($matches[2]);
+                            foreach ($prop['file_dependency'] as $_file_to_check) {
+                                If (is_file($_file_to_check[0])) {
+                                    $mtime = filemtime($_file_to_check[0]);
+                                } else {
+                                    $tpl->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]) {
+                                    $must_compile = true;
+                                    break;
+                                } 
+                            } 
+                            if ($must_compile) {
+                                // recompile
+                                $tpl->compileTemplateSource();
+                            } 
+                        } 
+                    } while ($must_compile);
+                    if (isset($prop['file_dependency'])) {
+                        $compiler->template->properties['file_dependency'] = array_merge($compiler->template->properties['file_dependency'], $prop['file_dependency']);
+                    } 
+                    $has_compiled_template = true;
+                }
+				}
+            } 
+        } 
+
+        if (isset($_attr['assign'])) {
+            // output will be stored in a smarty variable instead of beind displayed
+            $_assign = $_attr['assign'];
+        } 
+
+        $_parent_scope = SMARTY_LOCAL_SCOPE;
+        if (isset($_attr['scope'])) {
+            if ($_attr['scope'] == '\'parent\'') {
+                $_parent_scope = SMARTY_PARENT_SCOPE;
+            } elseif ($_attr['scope'] == '\'root\'') {
+                $_parent_scope = SMARTY_ROOT_SCOPE;
+            } elseif ($_attr['scope'] == '\'global\'') {
+                $_parent_scope = SMARTY_GLOBAL_SCOPE;
+            } 
+        } 
+        // default for included templates
+        if ($compiler->template->caching) {
+            $_caching = SMARTY_CACHING_LIFETIME_CURRENT;
+        } else {
+            $_caching = SMARTY_CACHING_OFF;
+        } 
+        /*
+        * if the {include} tag provides individual parameter for caching
+        * it will not be included into the common cache file and treated like
+        * a nocache section
+        */
+        if (isset($_attr['cache_lifetime'])) {
+            $_cache_lifetime = $_attr['cache_lifetime'];
+            $this->compiler->tag_nocache = true;
+        } 
+        if (isset($_attr['nocache'])) {
+            if ($_attr['nocache'] == 'true') {
+                $this->compiler->tag_nocache = true;
+            } 
+        } 
+        if (isset($_attr['caching'])) {
+            if ($_attr['caching'] == 'true') {
+                $_caching = SMARTY_CACHING_LIFETIME_CURRENT;
+            } else {
+                $_caching = SMARTY_CACHING_OFF;
+            } 
+        } 
+        // create template object
+        $_output = "<?php \$_template = new Smarty_Template ($include_file, \$_smarty_tpl->smarty, \$_smarty_tpl, \$_smarty_tpl->cache_id,  \$_smarty_tpl->compile_id);"; 
+        // delete {include} standard attributes
+        unset($_attr['file'], $_attr['assign'], $_attr['cache_lifetime'], $_attr['nocache'], $_attr['caching'], $_attr['scope']); 
+        // remaining attributes must be assigned as smarty variable
+        if (!empty($_attr)) {
+            if ($_parent_scope == SMARTY_LOCAL_SCOPE) {
+                // create variables
+                foreach ($_attr as $_key => $_value) {
+                    $_output .= "\$_template->assign('$_key',$_value);";
+                } 
+            } else {
+                $this->compiler->trigger_template_error('variable passing not allowed in parent/global scope');
+            } 
+        } 
+        // add caching parameter if required
+        if (isset($_cache_lifetime)) {
+            $_output .= "\$_template->cache_lifetime = $_cache_lifetime;";
+            $_caching = SMARTY_CACHING_LIFETIME_CURRENT;
+        } 
+        $_output .= "\$_template->caching = $_caching;"; 
+        // was there an assign attribute
+        if (isset($_assign)) {
+            $_output .= "\$_smarty_tpl->assign($_assign,\$_template->fetch()); ?>";
+        } else {
+            if ($has_compiled_template) {
+                $_output .= " \$_tpl_stack[] = \$_smarty_tpl; \$_smarty_tpl = \$_template;?>\n";
+                $_output .= $compiled_tpl . "<?php /*  End of included template \"" . $tpl->getTemplateFilepath() . "\" */ ?>";
+                $_output .= "<?php  \$_smarty_tpl = array_pop(\$_tpl_stack);?>";
+            } else {
+                $_output .= " echo \$_template->fetch(); ?>";
+            } 
+        } 
+        if ($_parent_scope != SMARTY_LOCAL_SCOPE) {
+            $_output .= "<?php \$_template->updateParentVariables($_parent_scope); ?>";
+        } 
+        $_output .= "<?php unset(\$_template); ?>";
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_include_php.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Include PHP
+* 
+* Compiles the {include_php} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Insert Class
+*/
+class Smarty_Internal_Compile_Include_Php extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {include_php} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('file');
+        $this->optional_attributes = array('once', 'assign'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $_output = '<?php '; 
+        // save posible attributes
+        $_file = $_attr['file'];
+        $_file = realpath(trim($_file, "'"));
+
+        if ($this->smarty->security) {
+            $this->smarty->security_handler->isTrustedPHPDir($_file);
+        } 
+
+        if ($_file === false) {
+            $this->compiler->trigger_template_error('include_php: file "' . $_attr['file'] . '" is not readable');
+        } 
+
+        if ($this->smarty->security) {
+            $this->smarty->security_handler->isTrustedPHPDir($_file);
+        } 
+
+        if (isset($_attr['assign'])) {
+            // output will be stored in a smarty variable instead of being displayed
+            $_assign = $_attr['assign'];
+        } 
+        $_once = '_once';
+        if (isset($_attr['once'])) {
+            if ($_attr['once'] == 'false') {
+                $_once = '';
+            } 
+        } 
+
+        $_output = '<?php ';
+        if (isset($_assign)) {
+            $_output .= 'ob_start(); include' . $_once . ' (\'' . $_file . '\'); $_smarty_tpl->assign(' . $_assign . ',ob_get_contents()); ob_end_clean();?>';
+        } else {
+            $this->compiler->has_output = true;
+            $_output .= 'include' . $_once . ' (\'' . $_file . '\'); ?>';
+        } 
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_insert.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Insert
+* 
+* Compiles the {insert} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Insert Class
+*/
+class Smarty_Internal_Compile_Insert extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {insert} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        $this->required_attributes = array('name');
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        // this tag must not be cached
+        $this->compiler->tag_nocache = true;
+
+        $_output = '<?php '; 
+        // save posible attributes
+        $_name = 'insert_' . trim($_attr['name'], "'\"");
+        if (isset($_attr['assign'])) {
+            // output will be stored in a smarty variable instead of beind displayed
+            $_assign = $_attr['assign'];
+            // create variable to make shure that the compiler knows about its nocache status
+            $this->compiler->template->tpl_vars[trim($_attr['assign'],"'")] = new Smarty_Variable(null,true);
+        } 
+        if (isset($_attr['script'])) {
+            // script which must be included
+            $_script = $_attr['script'];
+            if (!file_exists($_script)) {
+                $this->compiler->trigger_template_error('missing file "' . $_script . '"');
+            } 
+            // code for script file loading
+            $_output .= 'require once ' . $_script . ';';
+        } else {
+            if (!is_callable($_name)) {
+                $this->compiler->trigger_template_error('function "' . $_name . '" is not callable');
+            } 
+        } 
+        // delete {insert} standard attributes
+        unset($_attr['name'], $_attr['assign'], $_attr['script']); 
+        // convert attributes into parameter array string
+        $_paramsArray = array();
+        foreach ($_attr as $_key => $_value) {
+            $_paramsArray[] = "'$_key'=>$_value";
+        } 
+        $_params = 'array(' . implode(",", $_paramsArray) . ')'; 
+        // call insert
+        if (isset($_assign)) {
+            $_output .= '$_smarty_tpl->assign(' . $_assign . ',' . $_name . '(' . $_params . '),true); ?>';
+        } else {
+            $this->compiler->has_output = true;
+            $_output .= 'echo ' . $_name . '(' . $_params . '); ?>';
+        } 
+        return $_output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_nocache.php

@@ -0,0 +1,59 @@
+<?php
+
+/**
+* Smarty Internal Plugin Compile Nocache
+*
+* Compiles the {nocache} {/nocache} tags 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews
+*/
+/**
+* Smarty Internal Plugin Compile Nocache Class
+*/ 
+class Smarty_Internal_Compile_Nocache extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {nocache} tag
+    *
+    * This tag does not generate compiled output. It only sets a compiler flag 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        $_attr = $this->_get_attributes($args);
+        // enter nocache mode
+        $this->compiler->nocache = true;
+        // this tag does not return compiled code
+        $this->compiler->has_code = false;
+        return true;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Nocacheclose Class
+*/ 
+class Smarty_Internal_Compile_Nocacheclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/nocache} tag
+    *
+    * This tag does not generate compiled output. It only sets a compiler flag 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        $_attr = $this->_get_attributes($args);
+        // leave nocache mode
+        $this->compiler->nocache = false;
+        // this tag does not return compiled code
+        $this->compiler->has_code = false;
+        return true;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_object_block_function.php

@@ -0,0 +1,58 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Object Block Function
+* 
+* Compiles code for registered objects as block function
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Object Block Function Class
+*/
+class Smarty_Internal_Compile_Object_Block_Function extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the execution of block plugin
+    * 
+    * @param array $args array with attributes from parser
+    * @param string $tag name of block function
+    * @param string $methode name of methode to call
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler, $tag, $methode)
+    {
+        $this->compiler = $compiler; 
+        if (strlen($tag) < 5 || substr_compare($tag, 'close', -5, 5) != 0) {
+            // opening tag of block plugin
+            $this->required_attributes = array();
+            $this->optional_attributes = array('_any'); 
+
+            // check and get attributes
+            $_attr = $this->_get_attributes($args);
+
+            // convert attributes into parameter array string
+            $_paramsArray = array();
+            foreach ($_attr as $_key => $_value) {
+                $_paramsArray[] = "'$_key'=>$_value";
+            } 
+            $_params = 'array(' . implode(",", $_paramsArray) . ')'; 
+            
+            $this->_open_tag($tag.'->'.$methode, $_params);
+
+            // compile code
+            $output = '<?php $_block_repeat=true; $_smarty_tpl->smarty->registered_objects[\''.$tag.'\'][0]->' . $methode . '(' . $_params . ', null, $_smarty_tpl->smarty, $_block_repeat, $_smarty_tpl);while ($_block_repeat) { ob_start();?>';
+        } else {
+            // closing tag of block plugin
+            $_params = $this->_close_tag(substr($tag,0,-5).'->'.$methode);
+            // This tag does create output
+            $this->compiler->has_output = true;
+            // compile code
+            $output = '<?php $_block_content = ob_get_contents(); ob_end_clean(); $_block_repeat=false; echo $_smarty_tpl->smarty->registered_objects[\''.substr($tag,0,-5).'\'][0]->' . $methode . '(' . $_params . ', $_block_content, $_smarty_tpl->smarty, $_block_repeat, $_smarty_tpl); }?>';
+        } 
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_object_function.php

@@ -0,0 +1,47 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Object Funtion
+* 
+* Compiles code for registered objects as function
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Object Function Class
+*/
+class Smarty_Internal_Compile_Object_Function extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the execution of function plugin
+    * 
+    * @param array $args array with attributes from parser
+    * @param string $tag name of function
+    * @param string $methode name of methode to call
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler, $tag, $methode)
+    {
+        $this->compiler = $compiler; 
+        // This tag does create output
+        $this->compiler->has_output = true;
+
+        $this->required_attributes = array();
+        $this->optional_attributes = array('_any'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        // convert attributes into parameter array string
+        $_paramsArray = array();
+        foreach ($_attr as $_key => $_value) {
+            $_paramsArray[] = "'$_key'=>$_value";
+        } 
+        $_params = 'array(' . implode(",", $_paramsArray) . ')'; 
+        // compile code
+        $output = '<?php echo $_smarty_tpl->smarty->registered_objects[\''.$tag.'\'][0]->' . $methode . '(' . $_params . ',$_smarty_tpl->smarty,$_smarty_tpl);?>';
+
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_print_expression.php

@@ -0,0 +1,61 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Print Expression
+* 
+* Compiles any tag which will output an expression or variable
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Print Expression Class
+*/
+class Smarty_Internal_Compile_Print_Expression extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for gererting output from any expression
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('value');
+        $this->optional_attributes = array('assign', 'nocache', 'filter', 'nofilter'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        if (isset($_attr['nocache'])) {
+            if ($_attr['nocache'] == 'true') {
+                $this->compiler->tag_nocache = true;
+            } 
+        } 
+
+        if (!isset($_attr['filter'])) {
+            $_attr['filter'] = 'null';
+        } 
+        if (isset($_attr['nofilter'])) {
+            if ($_attr['nofilter'] == 'true') {
+                $_attr['filter'] = 'false';
+            } 
+        } 
+
+        if (isset($_attr['assign'])) {
+            // assign output to variable
+            $output = '<?php $_smarty_tpl->assign(' . $_attr['assign'] . ',' . $_attr['value'] . ');?>';
+        } else {
+            // display value
+            $this->compiler->has_output = true;
+            if (isset($this->compiler->smarty->registered_filters['variable'])) {
+                $output = '<?php echo $this->smarty->filter_handler->execute(\'variable\', ' . $_attr['value'] . ',' . $_attr['filter'] . ');?>';
+            } else {
+                $output = '<?php echo ' . $_attr['value'] . ';?>';
+            } 
+        } 
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_section.php

@@ -0,0 +1,170 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Section
+* 
+* Compiles the {section} {sectionelse} {/section} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Section Class
+*/
+class Smarty_Internal_Compile_Section extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {section} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('name', 'loop');
+        $this->optional_attributes = array('start', 'step', 'max', 'show'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $this->_open_tag('section', array('section',$this->compiler->nocache));
+		// maybe nocache because of nocache variables
+		$this->compiler->nocache = $this->compiler->nocache | $this->compiler->tag_nocache;
+
+        $output = "<?php ";
+
+        $section_name = $_attr['name'];
+        
+        $output .= "unset(\$_smarty_tpl->tpl_vars['smarty']->value['section'][$section_name]);\n";
+        $section_props = "\$_smarty_tpl->tpl_vars['smarty']->value['section'][$section_name]";
+
+        foreach ($_attr as $attr_name => $attr_value) {
+            switch ($attr_name) {
+                case 'loop':
+                    $output .= "{$section_props}['loop'] = is_array(\$_loop=$attr_value) ? count(\$_loop) : max(0, (int)\$_loop); unset(\$_loop);\n";
+                    break;
+
+                case 'show':
+                    if (is_bool($attr_value))
+                        $show_attr_value = $attr_value ? 'true' : 'false';
+                    else
+                        $show_attr_value = "(bool)$attr_value";
+                    $output .= "{$section_props}['show'] = $show_attr_value;\n";
+                    break;
+
+                case 'name':
+                    $output .= "{$section_props}['$attr_name'] = $attr_value;\n";
+                    break;
+
+                case 'max':
+                case 'start':
+                    $output .= "{$section_props}['$attr_name'] = (int)$attr_value;\n";
+                    break;
+
+                case 'step':
+                    $output .= "{$section_props}['$attr_name'] = ((int)$attr_value) == 0 ? 1 : (int)$attr_value;\n";
+                    break;
+            } 
+        } 
+
+        if (!isset($_attr['show']))
+            $output .= "{$section_props}['show'] = true;\n";
+
+        if (!isset($_attr['loop']))
+            $output .= "{$section_props}['loop'] = 1;\n";
+
+        if (!isset($_attr['max']))
+            $output .= "{$section_props}['max'] = {$section_props}['loop'];\n";
+        else
+            $output .= "if ({$section_props}['max'] < 0)\n" . "    {$section_props}['max'] = {$section_props}['loop'];\n";
+
+        if (!isset($_attr['step']))
+            $output .= "{$section_props}['step'] = 1;\n";
+
+        if (!isset($_attr['start']))
+            $output .= "{$section_props}['start'] = {$section_props}['step'] > 0 ? 0 : {$section_props}['loop']-1;\n";
+        else {
+            $output .= "if ({$section_props}['start'] < 0)\n" . "    {$section_props}['start'] = max({$section_props}['step'] > 0 ? 0 : -1, {$section_props}['loop'] + {$section_props}['start']);\n" . "else\n" . "    {$section_props}['start'] = min({$section_props}['start'], {$section_props}['step'] > 0 ? {$section_props}['loop'] : {$section_props}['loop']-1);\n";
+        } 
+
+        $output .= "if ({$section_props}['show']) {\n";
+        if (!isset($_attr['start']) && !isset($_attr['step']) && !isset($_attr['max'])) {
+            $output .= "    {$section_props}['total'] = {$section_props}['loop'];\n";
+        } else {
+            $output .= "    {$section_props}['total'] = min(ceil(({$section_props}['step'] > 0 ? {$section_props}['loop'] - {$section_props}['start'] : {$section_props}['start']+1)/abs({$section_props}['step'])), {$section_props}['max']);\n";
+        } 
+        $output .= "    if ({$section_props}['total'] == 0)\n" . "        {$section_props}['show'] = false;\n" . "} else\n" . "    {$section_props}['total'] = 0;\n";
+
+        $output .= "if ({$section_props}['show']):\n";
+        $output .= "
+            for ({$section_props}['index'] = {$section_props}['start'], {$section_props}['iteration'] = 1;
+                 {$section_props}['iteration'] <= {$section_props}['total'];
+                 {$section_props}['index'] += {$section_props}['step'], {$section_props}['iteration']++):\n";
+        $output .= "{$section_props}['rownum'] = {$section_props}['iteration'];\n";
+        $output .= "{$section_props}['index_prev'] = {$section_props}['index'] - {$section_props}['step'];\n";
+        $output .= "{$section_props}['index_next'] = {$section_props}['index'] + {$section_props}['step'];\n";
+        $output .= "{$section_props}['first']      = ({$section_props}['iteration'] == 1);\n";
+        $output .= "{$section_props}['last']       = ({$section_props}['iteration'] == {$section_props}['total']);\n";
+
+        $output .= "?>";
+        return $output;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Sectionelse Class
+*/
+class Smarty_Internal_Compile_Sectionelse extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {sectionelse} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('section'));
+        $this->_open_tag('sectionelse',array('sectionelse', $this->compiler->nocache));
+
+        return "<?php endfor; else: ?>";
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Sectionclose Class
+*/
+class Smarty_Internal_Compile_Sectionclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/section} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+ 		// must endblock be nocache?
+		if ($this->compiler->nocache) {
+                 $this->compiler->tag_nocache = true;
+        }
+
+        list($_open_tag, $this->compiler->nocache) = $this->_close_tag(array('section', 'sectionelse'));
+
+        if ($_open_tag == 'sectionelse')
+            return "<?php endif; ?>";
+        else
+            return "<?php endfor; endif; ?>";
+    } 
+} 
+
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_special_smarty_variable.php

@@ -0,0 +1,106 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Special Smarty Variable
+* 
+* Compiles the special $smarty variables
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile special Smarty Variable Class
+*/
+class Smarty_Internal_Compile_Special_Smarty_Variable extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the speical $smarty variables
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $_index = explode(',', str_replace(array('][', '[', ']'), array(',', '', ''), $args));
+        $compiled_ref = ' ';
+        switch (trim($_index[0], "'")) {
+            case 'foreach':
+                return "\$_smarty_tpl->getVariable('smarty')->value$args";
+            case 'section':
+                return "\$_smarty_tpl->getVariable('smarty')->value$args";
+            case 'capture':
+                return "\$_smarty_tpl->smarty->_smarty_vars$args";
+            case 'now':
+                return 'time()';
+
+            case 'get':
+                $compiled_ref = "\$_GET";
+                break;
+
+            case 'post':
+                $compiled_ref = "\$_POST";
+                break;
+
+            case 'cookies':
+                $compiled_ref = "\$_COOKIE";
+                break;
+
+            case 'env':
+                $compiled_ref = "\$_ENV";
+                break;
+
+            case 'server':
+                $compiled_ref = "\$_SERVER";
+                break;
+
+            case 'session':
+                $compiled_ref = "\$_SESSION";
+                break;
+
+            case 'request':
+                $compiled_ref = "\$_REQUEST";
+                break;
+
+            case 'template':
+                $_template_name = basename($compiler->template->getTemplateFilepath());
+                return "'$_template_name'";
+
+            case 'current_dir':
+                $_template_dir_name = dirname($compiler->template->getTemplateFilepath());
+                return "'$_template_dir_name'";
+
+            case 'version':
+                $_version = Smarty::$_version;
+                return "'$_version'";
+
+            case 'const':
+                if ($compiler->smarty->security && !$compiler->smarty->security_policy->allow_constants) {
+                    $compiler->trigger_template_error("(secure mode) constants not permitted");
+                    break;
+                } 
+                return '@' . trim($_index[1], "'");
+
+            case 'config':
+                return "\$_smarty_tpl->getConfigVariable($_index[1])";
+            case 'ldelim':
+                $_ldelim = $compiler->smarty->left_delimiter;
+                return "'$_ldelim'";
+
+            case 'rdelim':
+                $_rdelim = $compiler->smarty->right_delimiter;
+                return "'$_rdelim'";
+
+            default:
+                $compiler->trigger_template_error('$smarty.' . trim($_index[0], "'") . ' is an unknown reference');
+                break;
+        } 
+        if (isset($_index[1])) {
+            array_shift($_index);
+            foreach ($_index as $_ind) {
+                $compiled_ref = $compiled_ref . "[$_ind]";
+            } 
+        } 
+        return $compiled_ref;
+    } 
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_strip.php

@@ -0,0 +1,59 @@
+<?php
+/**
+* Smarty Internal Plugin Compile Strip
+* 
+* Compiles the {strip} {/strip} tags
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile Strip Class
+*/
+class Smarty_Internal_Compile_Strip extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {strip} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $this->_open_tag('strip');
+
+        $_output = "<?php ob_start(); ?>";
+
+        return $_output;
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Stripclose Class
+*/
+class Smarty_Internal_Compile_Stripclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/strip} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+
+        $saved_attr = $this->_close_tag(array('strip'));
+
+        $_output = "<?php echo preg_replace('![\t ]*[\r\n]+[\t ]*!', '', ob_get_clean()); ?>\n";
+        return $_output;
+    } 
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compile_while.php

@@ -0,0 +1,66 @@
+<?php
+/**
+* Smarty Internal Plugin Compile While
+* 
+* Compiles the {while} tag
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Compile While Class
+*/
+class Smarty_Internal_Compile_While extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {while} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler;
+        $this->required_attributes = array('if condition'); 
+        // check and get attributes
+        $_attr = $this->_get_attributes($args);
+        $this->_open_tag('while', $this->compiler->nocache);
+
+        // maybe nocache because of nocache variables
+		$this->compiler->nocache = $this->compiler->nocache | $this->compiler->tag_nocache;
+
+		
+        if (is_array($args['if condition'])) {
+            $_output = " <?php if (!isset(\$_smarty_tpl->tpl_vars[".$args['if condition']['var']."])) \$_smarty_tpl->tpl_vars[".$args['if condition']['var']."] = new Smarty_Variable;\n";
+            $_output .= " while (\$_smarty_tpl->tpl_vars[".$args['if condition']['var']."]->value = ".$args['if condition']['value'].") {\n ?>";
+            return $_output;
+        } else {
+            return '<?php while (' . $args['if condition'] . ') { ?>';
+        } 
+    } 
+} 
+
+/**
+* Smarty Internal Plugin Compile Whileclose Class
+*/
+class Smarty_Internal_Compile_Whileclose extends Smarty_Internal_CompileBase {
+    /**
+    * Compiles code for the {/while} tag
+    * 
+    * @param array $args array with attributes from parser
+    * @param object $compiler compiler object
+    * @return string compiled code
+    */
+    public function compile($args, $compiler)
+    {
+        $this->compiler = $compiler; 
+ 		// must endblock be nocache?
+		if ($this->compiler->nocache) {
+                 $this->compiler->tag_nocache = true;
+        }
+        $this->compiler->nocache = $this->_close_tag(array('while'));
+        return "<?php }?>";
+    } 
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_compilebase.php

@@ -0,0 +1,109 @@
+<?php
+
+/**
+* Smarty Internal Plugin CompileBase
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+
+/*
+interface TagCompilerInterface {
+    public function compile($args, $compiler);
+}
+*/ 
+
+/**
+* This class does extend all internal compile plugins
+*/
+//abstract class Smarty_Internal_CompileBase implements TagCompilerInterface 
+abstract class Smarty_Internal_CompileBase 
+{
+    function __construct()
+    {
+        // initialize valid attributes
+        $this->required_attributes = array();
+        $this->optional_attributes = array();
+    } 
+
+    /**
+    * This function checks if the attributes passed are valid
+    * 
+    * The attributes passed for the tag to compile are checked against the list of required and 
+    * optional attributes. Required attributes must be present. Optional attributes are check against
+    * against the corresponding list. The keyword '_any' specifies that any attribute will be accepted 
+    * as valid
+    * 
+    * @todo More generallized handling of the nocache attributes in compile plugins
+    * @param array $args attributes applied to the tag
+    * @return array attributes for further processing
+    */
+    function _get_attributes ($args)
+    { 
+        // check if all required attributes present
+        foreach ($this->required_attributes as $attr) {
+            if (!array_key_exists($attr, $args)) {
+                $this->compiler->trigger_template_error("missing \"" . $attr . "\" attribute");
+            } 
+        } 
+        // check for unallowed attributes
+        if ($this->optional_attributes != array('_any')) {
+            $tmp_array = array_merge($this->required_attributes, $this->optional_attributes);
+            foreach ($args as $key => $dummy) {
+                 if (!in_array($key, $tmp_array) && $key !== 0) {
+                   $this->compiler->trigger_template_error("unexspected \"" . $key . "\" attribute");
+                } 
+            } 
+        } 
+
+        return $args;
+    } 
+
+    /**
+    * Push opening tag name on stack
+    * 
+    * Optionally additional data can be saved on stack
+    * 
+    * @param string $open_tag the opening tag's name
+    * @param anytype $data optional data which shall be saved on stack
+    */
+    function _open_tag($open_tag, $data = null)
+    {
+        array_push($this->compiler->_tag_stack, array($open_tag, $data));
+    } 
+
+    /**
+    * Pop closing tag
+    * 
+    * Raise an error if this stack-top doesn't match with expected opening tags
+    * 
+    * @param array $ |string $expected_tag the expected opening tag names
+    * @return anytype the opening tag's name or saved data
+    */
+    function _close_tag($expected_tag)
+    {
+        if (count($this->compiler->_tag_stack) > 0) {
+            // get stacked info
+            list($_open_tag, $_data) = array_pop($this->compiler->_tag_stack); 
+            // open tag must match with the expected ones
+            if (in_array($_open_tag, (array)$expected_tag)) {
+                if (is_null($_data)) {
+                    // return opening tag
+                    return $_open_tag;
+                } else {
+                    // return restored data
+                    return $_data;
+                } 
+            } 
+            // wrong nesting of tags
+            $this->compiler->trigger_template_error("unclosed {" . $_open_tag . "} tag");
+            return;
+        } 
+        // wrong nesting of tags
+        $this->compiler->trigger_template_error("unexpected closing tag");
+        return;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_config.php

@@ -0,0 +1,249 @@
+<?php
+/**
+* Smarty Internal Plugin Config
+* 
+* Main class for config variables
+* 
+* @ignore 
+* @package Smarty
+* @subpackage Config
+* @author Uwe Tews 
+*/
+class Smarty_Internal_Config {
+    static $config_objects = array();
+
+    public function __construct($config_resource, $smarty, $template = null)
+    {
+        $this->template = $template;
+        $this->smarty = $smarty;
+        $this->config_resource = $config_resource;
+        $this->config_resource_type = null;
+        $this->config_resource_name = null;
+        $this->config_filepath = null;
+        $this->config_timestamp = null;
+        $this->config_source = null;
+        $this->compiled_config = null;
+        $this->compiled_filepath = null;
+        $this->compiled_timestamp = null;
+        $this->mustCompile = null;
+        $this->compiler_object = null; 
+        // parse config resource name
+        if (!$this->parseConfigResourceName ($config_resource)) {
+            throw new Exception ("Unable to parse config resource '{$config_resource}'");
+        } 
+    } 
+
+    public function getConfigFilepath ()
+    {
+        return $this->config_filepath === null ?
+        $this->config_filepath = $this->buildConfigFilepath() :
+        $this->config_filepath;
+    } 
+
+    public function getTimestamp ()
+    {
+        return $this->config_timestamp === null ?
+        $this->config_timestamp = filemtime($this->getConfigFilepath()) :
+        $this->config_timestamp;
+    } 
+
+    private function parseConfigResourceName($config_resource)
+    {
+        if (empty($config_resource))
+            return false;
+        if (strpos($config_resource, ':') === false) {
+            // no resource given, use default
+            $this->config_resource_type = $this->smarty->default_config_type;
+            $this->config_resource_name = $config_resource;
+        } else {
+            // get type and name from path
+            list($this->config_resource_type, $this->config_resource_name) = explode(':', $config_resource, 2);
+            if (strlen($this->config_resource_type) == 1) {
+                // 1 char is not resource type, but part of filepath
+                $this->config_resource_type = $this->smarty->default_config_type;
+                $this->config_resource_name = $config_resource;
+            } else {
+                $this->config_resource_type = strtolower($this->config_resource_type);
+            } 
+        } 
+        return true;
+    } 
+
+    /*
+     * get system filepath to config
+     */
+    public function buildConfigFilepath ()
+    {
+        foreach((array)$this->smarty->config_dir as $_config_dir) {
+            if (strpos('/\\', substr($_config_dir, -1)) === false) {
+                $_config_dir .= DS;
+            } 
+
+            $_filepath = $_config_dir . $this->config_resource_name;
+            if (file_exists($_filepath))
+                return $_filepath;
+        } 
+        // no tpl file found
+        throw new Exception("Unable to load config file \"{$this->config_resource_name}\"");
+        return false;
+    } 
+    /**
+    * Read config file source
+    * 
+    * @return string content of source file
+    */
+    /**
+    * Returns the template source code
+    * 
+    * The template source is being read by the actual resource handler
+    * 
+    * @return string the template source
+    */
+    public function getConfigSource ()
+    {
+        if ($this->config_source === null) {
+            if ($this->readConfigSource($this) === false) {
+                throw new Exception("Unable to load config file \"{$this->config_resource_name}\"");
+            } 
+        } 
+        return $this->config_source;
+    } 
+    public function readConfigSource()
+    { 
+        // read source file
+        if (file_exists($this->getConfigFilepath())) {
+            $this->config_source = file_get_contents($this->getConfigFilepath());
+            return true;
+        } else {
+            return false;
+        } 
+    } 
+
+    /**
+    * Returns the compiled  filepath
+    * 
+    * @return string the compiled filepath
+    */
+    public function getCompiledFilepath ()
+    {
+        return $this->compiled_filepath === null ?
+        ($this->compiled_filepath = $this->buildCompiledFilepath()) :
+        $this->compiled_filepath;
+    } 
+    public function buildCompiledFilepath()
+    {
+        $_flag = (int)$this->smarty->config_read_hidden + (int)$this->smarty->config_booleanize * 2 +
+        (int)$this->smarty->config_overwrite * 4;
+        $_filepath = (string)abs(crc32($this->config_resource_name . $_flag)); 
+        // if use_sub_dirs, break file into directories
+        if ($this->smarty->use_sub_dirs) {
+            $_filepath = substr($_filepath, 0, 2) . DS
+             . substr($_filepath, 2, 2) . DS
+             . substr($_filepath, 4, 2) . DS
+             . $_filepath;
+        } 
+        $_compile_dir = $this->smarty->compile_dir;
+        if (substr($_compile_dir, -1) != DS) {
+            $_compile_dir .= DS;
+        } 
+        return $_compile_dir . $_filepath . '.' . basename($this->config_resource_name) . '.config' . $this->smarty->php_ext;
+    } 
+    /**
+    * Returns the timpestamp of the compiled file
+    * 
+    * @return integer the file timestamp
+    */
+    public function getCompiledTimestamp ()
+    {
+        return $this->compiled_timestamp === null ?
+        ($this->compiled_timestamp = (file_exists($this->getCompiledFilepath())) ? filemtime($this->getCompiledFilepath()) : false) :
+        $this->compiled_timestamp;
+    } 
+    /**
+    * Returns if the current config file must be compiled 
+    * 
+    * It does compare the timestamps of config source and the compiled config and checks the force compile configuration
+    * 
+    * @return boolean true if the file must be compiled
+    */
+    public function mustCompile ()
+    {
+        return $this->mustCompile === null ?
+        $this->mustCompile = ($this->smarty->force_compile || $this->getCompiledTimestamp () !== $this->getTimestamp ()):
+        $this->mustCompile;
+    } 
+    /**
+    * Returns the compiled config file 
+    * 
+    * It checks if the config file must be compiled or just read the compiled version
+    * 
+    * @return string the compiled config file
+    */
+    public function getCompiledConfig ()
+    {
+        if ($this->compiled_config === null) {
+            // see if template needs compiling.
+            if ($this->mustCompile()) {
+                $this->compileConfigSource();
+            } else {
+                $this->compiled_config = file_get_contents($this->getCompiledFilepath());
+            } 
+        } 
+        return $this->compiled_config;
+    } 
+
+    /**
+    * Compiles the config files
+    */
+    public function compileConfigSource ()
+    { 
+        // compile template
+        if (!is_object($this->compiler_object)) {
+            // load compiler
+            $this->compiler_object = new Smarty_Internal_Config_File_Compiler($this->smarty);
+        } 
+        // call compiler
+        if ($this->compiler_object->compileSource($this)) {
+            // compiling succeded
+            // write compiled template
+            Smarty_Internal_Write_File::writeFile($this->getCompiledFilepath(), $this->getCompiledConfig()); 
+            // make template and compiled file timestamp match
+            touch($this->getCompiledFilepath(), $this->getTimestamp());
+        } else {
+            // error compiling template
+            throw new Exception("Error compiling template {$this->getConfigFilepath ()}");
+            return false;
+        } 
+    } 
+
+    /*
+     * load config variables
+    *
+    * @param mixed $sections array of section names, single section or null
+    * @param object $scope global,parent or local
+    */
+    public function loadConfigVars ($sections = null, $scope)
+    {
+        if (isset($this->template)) {
+            $this->template->properties['file_dependency']['F' . abs(crc32($this->getConfigFilepath()))] = array($this->getConfigFilepath(), $this->getTimestamp());
+        } else {
+            $this->smarty->properties['file_dependency']['F' . abs(crc32($this->getConfigFilepath()))] = array($this->getConfigFilepath(), $this->getTimestamp());
+        }
+        $config_data = unserialize($this->getCompiledConfig()); 
+        // var_dump($config_data);
+        // copy global config vars
+        foreach ($config_data['vars'] as $variable => $value) {
+            $scope->config_vars[$variable] = $value;
+        } 
+        // scan sections
+        foreach ($config_data['sections'] as $this_section => $dummy) {
+            if ($sections == null || in_array($this_section, (array)$sections)) {
+                foreach ($config_data['sections'][$this_section]['vars'] as $variable => $value) {
+                    $scope->config_vars[$variable] = $value;
+                } 
+            } 
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_config_file_compiler.php

@@ -0,0 +1,116 @@
+<?php
+
+/**
+* Smarty Internal Plugin Config File Compiler
+* 
+* This is the config file compiler class. It calls the lexer and parser to
+* perform the compiling.
+* 
+* @package Smarty
+* @subpackage Config
+* @author Uwe Tews 
+*/
+/**
+* Main config file compiler class
+*/
+class Smarty_Internal_Config_File_Compiler {
+   public $compile_error= false;
+   /**
+    * Initialize compiler
+    */
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty; 
+        // get required plugins
+        $this->smarty->loadPlugin('Smarty_Internal_Configfilelexer');
+        $this->smarty->loadPlugin('Smarty_Internal_Configfileparser');
+        $this->config_data['sections'] = array();
+        $this->config_data['vars'] = array();
+    } 
+
+    /**
+    * Methode to compile a Smarty template
+    * 
+    * @param  $template template object to compile
+    * @return bool true if compiling succeeded, false if it failed
+    */
+    public function compileSource($config)
+    {
+        /* here is where the compiling takes place. Smarty
+       tags in the templates are replaces with PHP code,
+       then written to compiled files. */ 
+       $this->config = $config; 
+       // get config file source
+        $_content = $config->getConfigSource();
+        // on empty template just return
+        if ($_content == '') {
+            return true;
+        } 
+        // init the lexer/parser to compile the config file
+        $lex = new Smarty_Internal_Configfilelexer($_content, $this->smarty);
+        $parser = new Smarty_Internal_Configfileparser($lex, $this); 
+        // $parser->PrintTrace();
+        // get tokens from lexer and parse them
+        while ($lex->yylex()) {
+            // echo "<br>Parsing  {$parser->yyTokenName[$lex->token]} Token {$lex->value} Line {$lex->line} \n";
+            $parser->doParse($lex->token, $lex->value);
+        } 
+        // finish parsing process
+        $parser->doParse(0, 0);
+
+        $config->compiled_config = serialize($this->config_data);
+        if (!$this->compile_error) {
+            return true;
+        } else {
+            // compilation error
+            return false;
+        } 
+    } 
+    /**
+    * display compiler error messages without dying
+    * 
+    * If parameter $args is empty it is a parser detected syntax error.
+    * In this case the parser is called to obtain information about exspected tokens.
+    * 
+    * If parameter $args contains a string this is used as error message
+    * 
+    * @todo output exact position of parse error in source line
+    * @param  $args string individual error message or null
+    */
+    public function trigger_config_file_error($args = null)
+    {
+        $this->lex = Smarty_Internal_Configfilelexer::instance();
+        $this->parser = Smarty_Internal_Configfileparser::instance(); 
+        // get template source line which has error
+        $line = $this->lex->line;
+        if (isset($args)) {
+//            $line--;
+        } 
+        $match = preg_split("/\n/", $this->lex->data);
+        $error_text = 'Syntax Error in config file "' . $this->config->getConfigFilepath() . '"  on line ' . $line . ' "'. $match[$line-1].'" ';
+        if (isset($args)) {
+            // individual error message
+            $error_text .= $args;
+        } else {
+            // exspected token from parser
+            foreach ($this->parser->yy_get_expected_tokens($this->parser->yymajor) as $token) {
+                $exp_token = $this->parser->yyTokenName[$token];
+                if (isset($this->lex->smarty_token_names[$exp_token])) {
+                    // token type from lexer
+                    $expect[] = '"' . $this->lex->smarty_token_names[$exp_token] . '"';
+                } else {
+                    // otherwise internal token name
+                    $expect[] = $this->parser->yyTokenName[$token];
+                } 
+            } 
+            // output parser error message
+            $error_text .= ' - Unexpected "' . $this->lex->value . '", expected one of: ' . implode(' , ', $expect);
+        } 
+        throw new Exception($error_text);
+        // set error flag
+        $this->compile_error = true;
+    } 
+
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_configfilelexer.php

@@ -0,0 +1,267 @@
+<?php
+/**
+* Smarty Internal Plugin Configfilelexer
+*
+* This is the lexer to break the config file source into tokens 
+* @package Smarty
+* @subpackage Config
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Configfilelexer
+*/
+class Smarty_Internal_Configfilelexer
+{
+
+    public $data;
+    public $counter;
+    public $token;
+    public $value;
+    public $node;
+    public $line;
+    private $state = 1;
+    public $smarty_token_names = array (		// Text for parser error messages
+   				);
+    				
+    				
+    function __construct($data, $smarty)
+    {
+        // set instance object
+        self::instance($this); 
+        $this->data = $data;
+        $this->counter = 0;
+        $this->line = 1;
+        $this->smarty = $smarty; 
+     }
+    public static function &instance($new_instance = null)
+    {
+        static $instance = null;
+        if (isset($new_instance) && is_object($new_instance))
+            $instance = $new_instance;
+        return $instance;
+    } 
+
+
+
+    private $_yy_state = 1;
+    private $_yy_stack = array();
+
+    function yylex()
+    {
+        return $this->{'yylex' . $this->_yy_state}();
+    }
+
+    function yypushstate($state)
+    {
+        array_push($this->_yy_stack, $this->_yy_state);
+        $this->_yy_state = $state;
+    }
+
+    function yypopstate()
+    {
+        $this->_yy_state = array_pop($this->_yy_stack);
+    }
+
+    function yybegin($state)
+    {
+        $this->_yy_state = $state;
+    }
+
+
+
+    function yylex1()
+    {
+        $tokenMap = array (
+              1 => 0,
+              2 => 0,
+              3 => 0,
+              4 => 0,
+              5 => 0,
+              6 => 0,
+              7 => 0,
+              8 => 1,
+              10 => 1,
+              12 => 0,
+              13 => 0,
+              14 => 0,
+              15 => 0,
+            );
+        if ($this->counter >= strlen($this->data)) {
+            return false; // end of input
+        }
+        $yy_global_pattern = "/^(#)|^('[^'\\\\\\\\]*(?:\\\\\\\\.[^'\\\\\\\\]*)*')|^(\"\"\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\"\"\")|^(\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\")|^(\\[)|^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)/";
+
+        do {
+            if (preg_match($yy_global_pattern, substr($this->data, $this->counter), $yymatches)) {
+                $yysubmatches = $yymatches;
+                $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
+                if (!count($yymatches)) {
+                    throw new Exception('Error: lexing failed because a rule matched' .
+                        'an empty string.  Input "' . substr($this->data,
+                        $this->counter, 5) . '... state START');
+                }
+                next($yymatches); // skip global match
+                $this->token = key($yymatches); // token number
+                if ($tokenMap[$this->token]) {
+                    // extract sub-patterns for passing to lex function
+                    $yysubmatches = array_slice($yysubmatches, $this->token + 1,
+                        $tokenMap[$this->token]);
+                } else {
+                    $yysubmatches = array();
+                }
+                $this->value = current($yymatches); // token value
+                $r = $this->{'yy_r1_' . $this->token}($yysubmatches);
+                if ($r === null) {
+                    $this->counter += strlen($this->value);
+                    $this->line += substr_count($this->value, "\n");
+                    // accept this token
+                    return true;
+                } elseif ($r === true) {
+                    // we have changed state
+                    // process this token in the new state
+                    return $this->yylex();
+                } elseif ($r === false) {
+                    $this->counter += strlen($this->value);
+                    $this->line += substr_count($this->value, "\n");
+                    if ($this->counter >= strlen($this->data)) {
+                        return false; // end of input
+                    }
+                    // skip this token
+                    continue;
+                } else {                    $yy_yymore_patterns = array(
+        1 => array(0, "^('[^'\\\\\\\\]*(?:\\\\\\\\.[^'\\\\\\\\]*)*')|^(\"\"\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\"\"\")|^(\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\")|^(\\[)|^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        2 => array(0, "^(\"\"\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\"\"\")|^(\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\")|^(\\[)|^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        3 => array(0, "^(\"[^\"\\\\\\\\]*(?:\\\\\\\\.[^\"\\\\\\\\]*)*\")|^(\\[)|^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        4 => array(0, "^(\\[)|^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        5 => array(0, "^(])|^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        6 => array(0, "^(\\s*=\\s*)|^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        7 => array(0, "^(\\d+(\\.\\d+)?)|^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        8 => array(1, "^((\n|\r\n))|^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        10 => array(2, "^([\s]+)|^(\\.)|^(\\w+)|^(.)"),
+        12 => array(2, "^(\\.)|^(\\w+)|^(.)"),
+        13 => array(2, "^(\\w+)|^(.)"),
+        14 => array(2, "^(.)"),
+        15 => array(2, ""),
+    );
+
+                    // yymore is needed
+                    do {
+                        if (!strlen($yy_yymore_patterns[$this->token][1])) {
+                            throw new Exception('cannot do yymore for the last token');
+                        }
+                        $yysubmatches = array();
+                        if (preg_match('/' . $yy_yymore_patterns[$this->token][1] . '/',
+                              substr($this->data, $this->counter), $yymatches)) {
+                            $yysubmatches = $yymatches;
+                            $yymatches = array_filter($yymatches, 'strlen'); // remove empty sub-patterns
+                            next($yymatches); // skip global match
+                            $this->token += key($yymatches) + $yy_yymore_patterns[$this->token][0]; // token number
+                            $this->value = current($yymatches); // token value
+                            $this->line = substr_count($this->value, "\n");
+                            if ($tokenMap[$this->token]) {
+                                // extract sub-patterns for passing to lex function
+                                $yysubmatches = array_slice($yysubmatches, $this->token + 1,
+                                    $tokenMap[$this->token]);
+                            } else {
+                                $yysubmatches = array();
+                            }
+                        }
+                    	$r = $this->{'yy_r1_' . $this->token}($yysubmatches);
+                    } while ($r !== null && !is_bool($r));
+			        if ($r === true) {
+			            // we have changed state
+			            // process this token in the new state
+			            return $this->yylex();
+                    } elseif ($r === false) {
+                        $this->counter += strlen($this->value);
+                        $this->line += substr_count($this->value, "\n");
+                        if ($this->counter >= strlen($this->data)) {
+                            return false; // end of input
+                        }
+                        // skip this token
+                        continue;
+			        } else {
+	                    // accept
+	                    $this->counter += strlen($this->value);
+	                    $this->line += substr_count($this->value, "\n");
+	                    return true;
+			        }
+                }
+            } else {
+                throw new Exception('Unexpected input at line' . $this->line .
+                    ': ' . $this->data[$this->counter]);
+            }
+            break;
+        } while (true);
+
+    } // end function
+
+
+    const START = 1;
+    function yy_r1_1($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_COMMENTSTART;
+    }
+    function yy_r1_2($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_SI_QSTR;
+    }
+    function yy_r1_3($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_ML_QSTR;
+    }
+    function yy_r1_4($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_DO_QSTR;
+    }
+    function yy_r1_5($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_OPENB;
+    }
+    function yy_r1_6($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_CLOSEB;
+    }
+    function yy_r1_7($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_EQUAL;
+    }
+    function yy_r1_8($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_NUMBER;
+    }
+    function yy_r1_10($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_EOL;
+    }
+    function yy_r1_12($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_SPACE;
+    }
+    function yy_r1_13($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_DOT;
+    }
+    function yy_r1_14($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_ID;
+    }
+    function yy_r1_15($yy_subpatterns)
+    {
+
+  $this->token = Smarty_Internal_Configfileparser::TPC_OTHER;
+    }
+
+}

onyx2/modules/templates/smarty/sysplugins/smarty_internal_debug.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+* Smarty Internal Plugin Debug
+* 
+* Class to collect data for the Smarty Debugging Consol
+* 
+* @package Smarty
+* @subpackage Debug
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Debug Class
+*/
+class Smarty_Internal_Debug extends Smarty_Internal_TemplateBase {
+    /**
+    * Opens a window for the Smarty Debugging Consol and display the data
+    */
+    public static function display_debug($smarty)
+    {
+        // get template names
+        $i = 0;
+        $_template_data = array();
+        if (is_array($smarty->template_objects)) {
+            foreach ($smarty->template_objects as $_template_obj) {
+                // exclude the debugging template from displayed data
+                if ($smarty->debug_tpl != $_template_obj->resource_name) {
+                    $_template_data[$i]['name'] = $_template_obj->getTemplateFilepath();
+                    $_template_data[$i]['compile_time'] = $_template_obj->compile_time;
+                    $_template_data[$i]['render_time'] = $_template_obj->render_time;
+                    $_template_data[$i]['cache_time'] = $_template_obj->cache_time;
+                    $i++;
+                    if (false && $i == 1) {
+                        foreach ($_template_obj->properties['file_dependency'] as $_file) {
+                            $_template_data[$i]['name'] = $_file[0];
+                            $_template_data[$i]['compile_time'] = 0;
+                            $_template_data[$i]['render_time'] = 0;
+                            $_template_data[$i]['cache_time'] = 0;
+                            $i++;
+                        } 
+                    } 
+                } 
+            } 
+        } 
+        // prepare information of assigned variables
+        $_assigned_vars = $smarty->tpl_vars;
+        ksort($_assigned_vars);
+        $_config_vars = $smarty->config_vars;
+        ksort($_config_vars);
+        $_template = new Smarty_Template ($smarty->debug_tpl, $smarty);
+        $_template->caching = false;
+        $_template->force_compile = false;
+        $_template->security = false;
+        $_template->assign('template_data', $_template_data);
+        $_template->assign('assigned_vars', $_assigned_vars);
+        $_template->assign('config_vars', $_config_vars);
+        $_template->assign('execution_time', $smarty->_get_time() - $smarty->start_time);
+        echo $smarty->fetch($_template);
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_plugin_handler.php

@@ -0,0 +1,104 @@
+<?php
+
+/**
+* Smarty Internal Plugin Handler
+* 
+* @package Smarty
+* @subpackage PluginsInternal
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Handler Class
+*/
+class Smarty_Internal_Plugin_Handler {
+    function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    /**
+    * Call a Smarty plugin
+    * 
+    * @param string $name block function name
+    * @param array $args $args[0] = array of plugin attributes and $args[1] = plugin types to search for
+    */
+    public function __call($name, $args)
+    {
+        if ($this->loadSmartyPlugin($name, $args[1])) {
+            // call plugin
+            return call_user_func_array($this->smarty->registered_plugins[$name][1], $args[0]);
+        } else {
+            // plugin not found
+            throw new Exception("Unable to load plugin {$name}");
+        } 
+    } 
+    public function executeModifier($name, $args, $check_array)
+    {
+        if ($this->loadSmartyPlugin($name, 'modifier')) {
+            // call plugin
+            if (!$check_array || !is_array($args[0])) {
+                return call_user_func_array($this->smarty->registered_plugins[$name][1], $args);
+            } else {
+                $args0 = $args[0];
+                foreach ($args0 as $key => $arg0) {
+                    $args[0] = $arg0;
+                    $result[$key] = call_user_func_array($this->smarty->registered_plugins[$name][1], $args);
+                } 
+                return $result;
+            } 
+        } elseif (is_callable($name)) {
+            if (!$check_array || !is_array($args[0])) {
+                return call_user_func_array($name, $args);
+            } else {
+                $args0 = $args[0];
+                foreach ($args0 as $key => $arg0) {
+                    $args[0] = $arg0;
+                    $result[$key] = call_user_func_array($name, $args);
+                } 
+                return $result;
+            } 
+        } else {
+            // plugin not found
+            throw new Exception("Unable to load plugin {$name}");
+        } 
+    } 
+    /**
+    * Lazy loads plugin files
+    * class name format: Smarty_PluginType_FuncName
+    * plugin filename format: plugintype.funcname.php
+    * 
+    * @param string $name plugin name
+    * @param array $type array of plugin types to search for
+    */
+    public function loadSmartyPlugin($name, $type)
+    { 
+        // load plugin if missing
+        if (isset($this->smarty->registered_plugins[$name])) {
+            return true;
+        } else {
+            foreach ((array)$type as $plugin_type) {
+                $plugin = 'smarty_' . $plugin_type . '_' . $name;
+                if ($this->smarty->loadPlugin($plugin)) {
+                    if (class_exists($plugin, false)) {
+                        $plugin = array(new $plugin, 'execute');
+                    } 
+                    if (is_callable($plugin)) {
+                        $this->smarty->registered_plugins[$name] = array($plugin_type, $plugin, true);
+                        return true;
+                    } else {
+                        throw new Exception("Plugin \"{$name}\" not callable");
+                    } 
+                } 
+            } 
+        } 
+        if (!empty($this->smarty->default_plugin_handler_func)) {
+            if (!is_callable($this->smarty->default_plugin_handler_func)) {
+                throw new Exception("Default template handler not callable");
+            } else {
+                return call_user_func_array($this->smarty->default_plugin_handler_func, array($name, $type, &$this));
+            } 
+        } 
+        return false;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_extend.php

@@ -0,0 +1,196 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource Extend
+* 
+* Implements the file system as resource for Smarty which does extend a chain of template files templates
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource Extend
+*/
+class Smarty_Internal_Resource_Extend {
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    // classes used for compiling Smarty templates from file resource
+    public $compiler_class = 'Smarty_Internal_SmartyTemplateCompiler';
+    public $template_lexer_class = 'Smarty_Internal_Templatelexer';
+    public $template_parser_class = 'Smarty_Internal_Templateparser';
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @param object $template template object
+    * @return boolean result
+    */
+    public function isExisting($template)
+    {
+        if ($template->getTemplateFilepath() === false) {
+            return false;
+        } else {
+            return true;
+        } 
+    } 
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $template template object
+    * @return string filepath to template source file
+    */
+    public function getTemplateFilepath($template)
+    {
+        $_files = explode('|', $template->resource_name);
+        $_filepath = $template->buildTemplateFilepath ($_files[count($_files)-1]);
+        if ($_filepath !== false) {
+            if ($template->security) {
+                $template->smarty->security_handler->isTrustedResourceDir($_filepath);
+            } 
+        } 
+        return $_filepath;
+    } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $template template object
+    * @return integer timestamp of template source file
+    */
+    public function getTemplateTimestamp($template)
+    {
+        return filemtime($template->getTemplateFilepath());
+    } 
+
+    /**
+    * Read template source from file
+    * 
+    * @param object $template template object
+    * @return string content of template source file
+    */
+    public function getTemplateSource($template)
+    {
+        $this->template = $template;
+        $_files = explode('|', $template->resource_name);
+        $_files = array_reverse($_files);
+        foreach ($_files as $_file) {
+            $_filepath = $template->buildTemplateFilepath ($_file); 
+            // read template file
+            if ($_filepath === false) {
+                throw new Exception("Unable to load template \"file : {$_file}\"");
+            } 
+            if ($_file != $_files[0]) {
+                $template->properties['file_dependency']['F' . abs(crc32($_filepath))] = array($_filepath, filemtime($_filepath));
+            } 
+            $_content = file_get_contents($_filepath);
+            if ($_file != $_files[count($_files)-1]) {
+                if (preg_match_all('/(' . $this->smarty->left_delimiter . 'block(.+?)' . $this->smarty->right_delimiter . ')/', $_content, $_open, PREG_OFFSET_CAPTURE) !=
+                        preg_match_all('/(' . $this->smarty->left_delimiter . '\/block(.*?)' . $this->smarty->right_delimiter . ')/', $_content, $_close, PREG_OFFSET_CAPTURE)) {
+                    $this->smarty->trigger_error(" unmatched {block} {/block} pairs");
+                } 
+                $_block_count = count($_open[0]);
+                for ($_i = 0; $_i < $_block_count; $_i++) {
+                    $_block_content = str_replace($this->smarty->left_delimiter . '$smarty.parent' . $this->smarty->right_delimiter, '%%%%SMARTY_PARENT%%%%',
+                        substr($_content, $_open[0][$_i][1] + strlen($_open[0][$_i][0]), $_close[0][$_i][1] - $_open[0][$_i][1] - strlen($_open[0][$_i][0])));
+                    $this->saveBlockData($_block_content, $_open[0][$_i][0]);
+                } 
+            } else {
+                $template->template_source = $_content;
+                return true;
+            } 
+        } 
+    } 
+    protected function saveBlockData($block_content, $block_tag)
+    {
+        if (0 == preg_match('/(.?)(name=)([^ ]*)/', $block_tag, $_match)) {
+            $this->smarty->trigger_error("\"" . $block_tag . "\" missing name attribute");
+        } else {
+            // compile block content
+            $_tpl = $this->smarty->createTemplate('string:' . $block_content);
+            $_tpl->template_filepath = $this->template->getTemplateFilepath();
+            $_tpl->suppressFileDependency = true;
+            $_compiled_content = $_tpl->getCompiledTemplate();
+            unset($_tpl);
+            $_name = trim($_match[3], "\"'}");
+
+            if (isset($this->smarty->block_data[$_name])) {
+                if (strpos($this->smarty->block_data[$_name]['compiled'], '%%%%SMARTY_PARENT%%%%') !== false) {
+                    $this->smarty->block_data[$_name]['compiled'] =
+                    str_replace('%%%%SMARTY_PARENT%%%%', $_compiled_content, $this->smarty->block_data[$_name]['compiled']);
+                } elseif ($this->smarty->block_data[$_name]['mode'] == 'prepend') {
+                    $this->smarty->block_data[$_name]['compiled'] .= $_compiled_content;
+                } elseif ($this->smarty->block_data[$_name]['mode'] == 'append') {
+                    $this->smarty->block_data[$_name]['compiled'] = $_compiled_content . $this->smarty->block_data[$_name]['compiled'];
+                } 
+            } else {
+                $this->smarty->block_data[$_name]['compiled'] = $_compiled_content;
+            } 
+            if (preg_match('/(.?)(append=true)(.*)/', $block_tag, $_match) != 0) {
+                $this->smarty->block_data[$_name]['mode'] = 'append';
+            } elseif (preg_match('/(.?)(prepend=true)(.*)/', $block_tag, $_match) != 0) {
+                $this->smarty->block_data[$_name]['mode'] = 'prepend';
+            } else {
+                $this->smarty->block_data[$_name]['mode'] = 'replace';
+            } 
+        } 
+    } 
+
+    /**
+    * Return flag that this resource uses the compiler
+    * 
+    * @return boolean true
+    */
+    public function usesCompiler()
+    { 
+        // template has tags, uses compiler
+        return true;
+    } 
+
+    /**
+    * Return flag that this is not evaluated
+    * 
+    * @return boolean false
+    */
+    public function isEvaluated()
+    { 
+        // save the compiled file to disk, do not evaluate
+        return false;
+    } 
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $template template object
+    * @return string return path to compiled template
+    */
+    public function getCompiledFilepath($template)
+    {
+        $_files = explode('|', $template->resource_name);
+        $_filepath = (string)abs(crc32($template->resource_name)); 
+        // if use_sub_dirs, break file into directories
+        if ($template->smarty->use_sub_dirs) {
+            $_filepath = substr($_filepath, 0, 2) . DS
+             . substr($_filepath, 2, 2) . DS
+             . substr($_filepath, 4, 2) . DS
+             . $_filepath;
+        } 
+        $_compile_dir_sep = $template->smarty->use_sub_dirs ? DS : '^';
+        if (isset($template->compile_id)) {
+            $_filepath = $template->compile_id . $_compile_dir_sep . $_filepath;
+        } 
+        if ($template->caching) {
+            $_cache = '.cache';
+        } else {
+            $_cache = '';
+        } 
+        $_compile_dir = $template->smarty->compile_dir;
+        if (substr($_compile_dir, -1) != DS) {
+            $_compile_dir .= DS;
+        } 
+        return $_compile_dir . $_filepath . '.' . basename($_files[count($_files)-1]) . $_cache . $template->smarty->php_ext;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_file.php

@@ -0,0 +1,140 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource File
+* 
+* Implements the file system as resource for Smarty templates
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource File
+*/
+class Smarty_Internal_Resource_File {
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    // classes used for compiling Smarty templates from file resource
+    public $compiler_class = 'Smarty_Internal_SmartyTemplateCompiler';
+    public $template_lexer_class = 'Smarty_Internal_Templatelexer';
+    public $template_parser_class = 'Smarty_Internal_Templateparser';
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @return boolean true
+    */
+    public function isExisting($template)
+    {
+        if ($template->getTemplateFilepath() === false) {
+            return false;
+        } else {
+            return true;
+        } 
+    } 
+
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $_template template object
+    * @return string filepath to template source file
+    */
+    public function getTemplateFilepath($_template)
+    {
+        $_filepath = $_template->buildTemplateFilepath ();
+
+        if ($_filepath !== false) {
+            if ($_template->security) {
+                $_template->smarty->security_handler->isTrustedResourceDir($_filepath);
+            } 
+        } 
+        return $_filepath;
+    } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $_template template object
+    * @return integer timestamp of template source file
+    */
+    public function getTemplateTimestamp($_template)
+    {
+        return filemtime($_template->getTemplateFilepath());
+    } 
+
+    /**
+    * Read template source from file
+    * 
+    * @param object $_template template object
+    * @return string content of template source file
+    */
+    public function getTemplateSource($_template)
+    { 
+        // read template file
+        if (file_exists($_template->getTemplateFilepath())) {
+            $_template->template_source = file_get_contents($_template->getTemplateFilepath());
+            return true;
+        } else {
+            return false;
+        } 
+    } 
+
+    /**
+    * Return flag that this resource uses the compiler
+    * 
+    * @return boolean true
+    */
+    public function usesCompiler()
+    { 
+        // template has tags, uses compiler
+        return true;
+    } 
+
+    /**
+    * Return flag that this is not evaluated
+    * 
+    * @return boolean false
+    */
+    public function isEvaluated()
+    { 
+        // save the compiled file to disk, do not evaluate
+        return false;
+    } 
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $_template template object
+    * @return string return path to compiled template
+    */
+    public function getCompiledFilepath($_template)
+    { 
+        // $_filepath = md5($_template->resource_name);
+        $_filepath = (string)abs(crc32($_template->resource_name)); 
+        // if use_sub_dirs, break file into directories
+        if ($_template->smarty->use_sub_dirs) {
+            $_filepath = substr($_filepath, 0, 2) . DS
+             . substr($_filepath, 2, 2) . DS
+             . substr($_filepath, 4, 2) . DS
+             . $_filepath;
+        } 
+        $_compile_dir_sep = $_template->smarty->use_sub_dirs ? DS : '^';
+        if (isset($_template->compile_id)) {
+            $_filepath = $_template->compile_id . $_compile_dir_sep . $_filepath;
+        } 
+        if ($_template->caching) {
+            $_cache = '.cache';
+        } else {
+            $_cache = '';
+        } 
+        $_compile_dir = $_template->smarty->compile_dir;
+        if (strpos('/\\', substr($_compile_dir, -1)) === false) {
+            $_compile_dir .= DS;
+        } 
+        return $_compile_dir . $_filepath . '.' . $_template->resource_type . '.' . basename($_template->resource_name). $_cache . $_template->smarty->php_ext;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_php.php

@@ -0,0 +1,145 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource PHP
+* 
+* Implements the file system as resource for PHP templates
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource PHP
+*/
+class Smarty_Internal_Resource_PHP {
+    /**
+    * Class constructor, enable short open tags
+    */
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+        ini_set('short_open_tag', '1');
+    } 
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @return boolean true
+    */
+    public function isExisting($template)
+    {
+        if ($template->getTemplateFilepath() === false) {
+            return false;
+        } else {
+            return true;
+        } 
+    } 
+
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $_template template object
+    * @return string filepath to template source file
+    */
+    public function getTemplateFilepath($_template)
+    {
+        $_filepath = $_template->buildTemplateFilepath ();
+
+        if ($_template->security) {
+            $_template->smarty->security_handler->isTrustedResourceDir($_filepath);
+        } 
+
+        return $_filepath;
+    } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $_template template object
+    * @return integer timestamp of template source file
+    */
+    public function getTemplateTimestamp($_template)
+    {
+        return filemtime($_template->getTemplateFilepath());
+    } 
+
+    /**
+    * Read template source from file
+    * 
+    * @param object $_template template object
+    * @return string content of template source file
+    */
+    public function getTemplateSource($_template)
+    {
+        if (file_exists($_template->getTemplateFilepath())) {
+            $_template->template_source = file_get_contents($_template->getTemplateFilepath());
+            return true;
+        } else {
+            return false;
+        } 
+    } 
+
+    /**
+    * Return flag that this resource not use the compiler
+    * 
+    * @return boolean false
+    */
+    public function usesCompiler()
+    { 
+        // does not use compiler, template is PHP
+        return false;
+    } 
+
+    /**
+    * Return flag that this is not evaluated
+    * 
+    * @return boolean false
+    */
+    public function isEvaluated()
+    { 
+        // does not use compiler, must be false
+        return false;
+    } 
+
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $_template template object
+    * @return boolean return false as compiled template is not stored
+    */
+    public function getCompiledFilepath($_template)
+    { 
+        // no filepath for PHP templates
+        return false;
+    } 
+
+    /**
+    * renders the PHP template
+    */
+    public function renderUncompiled($_smarty_template)
+    {
+        if (!$this->smarty->allow_php_templates) {
+            throw new Exception("PHP templates are disabled");
+        } 
+        if ($this->getTemplateFilepath($_smarty_template) === false) {
+            throw new Exception("Unable to load template \"{$_smarty_template->resource_type} : {$_smarty_template->resource_name}\"");
+        } 
+        // prepare variables
+        $_smarty_ptr = $_smarty_template;
+        do {
+            foreach ($_smarty_ptr->tpl_vars as $_smarty_var => $_smarty_var_object) {
+                if (isset($_smarty_var_object->value)) {
+                    $$_smarty_var = $_smarty_var_object->value;
+                } 
+            } 
+            $_smarty_ptr = $_smarty_ptr->parent;
+        } while ($_smarty_ptr != null);
+        unset ($_smarty_var, $_smarty_var_object, $_smarty_ptr); 
+        // include PHP template
+        include($this->getTemplateFilepath($_smarty_template));
+        return;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_registered.php

@@ -0,0 +1,152 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource Registered
+* 
+* Implements the registered resource for Smarty template
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource Registered
+*/
+
+class Smarty_Internal_Resource_Registered {
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    // classes used for compiling Smarty templates from file resource
+    public $compiler_class = 'Smarty_Internal_SmartyTemplateCompiler';
+    public $template_lexer_class = 'Smarty_Internal_Templatelexer';
+    public $template_parser_class = 'Smarty_Internal_Templateparser';
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @return boolean true
+    */
+    public function isExisting($_template)
+    {
+        if (is_integer($this->getTemplateTimestamp($_template))) {
+            return true;
+        } else {
+            return false;
+        } 
+    } 
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $_template template object
+    * @return string return 'string' as template source is not a file
+    */
+    public function getTemplateFilepath($_template)
+    { 
+        // no filepath for strings
+        // return "string" for compiler error messages
+           $_filepath = $_template->resource_type .':'.$_template->resource_name;
+
+        return $_filepath;
+ } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $_template template object
+    * @return boolean false as string resources have no timestamp
+    */
+    public function getTemplateTimestamp($_template)
+    { 
+        // return timestamp
+        $time_stamp = false;
+        call_user_func_array($this->smarty->_plugins['resource'][$_template->resource_type][0][1],
+            array($_template->resource_name, &$time_stamp, $this->smarty));
+        return $time_stamp;
+    } 
+    /**
+    * Get timestamp to template source by type and name
+    * 
+    * @param object $_template template object
+    * @return boolean false as string resources have no timestamp
+    */
+    public function getTemplateTimestampTypeName($_resource_type, $_resource_name)
+    { 
+        // return timestamp
+        $time_stamp = false;
+        call_user_func_array($this->smarty->_plugins['resource'][$_resource_type][0][1],
+            array($_resource_name, &$time_stamp, $this->smarty));
+        return $time_stamp;
+    } 
+
+    /**
+    * Retuen template source from resource name
+    * 
+    * @param object $_template template object
+    * @return string content of template source
+    */
+    public function getTemplateSource($_template)
+    { 
+        // return template string
+        return call_user_func_array($this->smarty->_plugins['resource'][$_template->resource_type][0][0],
+            array($_template->resource_name, &$_template->template_source, $this->smarty));
+    } 
+
+    /**
+    * Return flag that this resource uses the compiler
+    * 
+    * @return boolean true
+    */
+    public function usesCompiler()
+    { 
+        // resource string is template, needs compiler
+        return true;
+    } 
+
+    /**
+    * Return flag that this resource is evaluated
+    * 
+    * @return boolean true
+    */
+    public function isEvaluated()
+    { 
+        // compiled template is evaluated instead of saved to disk
+        return false;
+    } 
+
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $_template template object
+    * @return boolean return false as compiled template is not stored
+    */
+    public function getCompiledFilepath($_template)
+    { 
+        // $_filepath = md5($_template->resource_name);
+        $_filepath = (string)abs(crc32($_template->template_resource)); 
+        // if use_sub_dirs, break file into directories
+        if ($_template->smarty->use_sub_dirs) {
+            $_filepath = substr($_filepath, 0, 2) . DS
+             . substr($_filepath, 2, 2) . DS
+             . substr($_filepath, 4, 2) . DS
+             . $_filepath;
+        } 
+        $_compile_dir_sep = $_template->smarty->use_sub_dirs ? DS : '^';
+        if (isset($_template->compile_id)) {
+            $_filepath = $_template->compile_id . $_compile_dir_sep . $_filepath;
+        } 
+        if ($_template->caching) {
+            $_cache = '.cache';
+        } else {
+            $_cache = '';
+        } 
+        $_compile_dir = $_template->smarty->compile_dir;
+        if (strpos('/\\', substr($_compile_dir, -1)) === false) {
+            $_compile_dir .= DS;
+        } 
+        return $_compile_dir . $_filepath . '.' . $_template->resource_type . '.' . basename($_template->resource_name) . $_cache . $_template->smarty->php_ext;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_stream.php

@@ -0,0 +1,118 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource Stream
+* 
+* Implements the streams as resource for Smarty template
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource Stream
+*/
+
+class Smarty_Internal_Resource_Stream {
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    // classes used for compiling Smarty templates from file resource
+    public $compiler_class = 'Smarty_Internal_SmartyTemplateCompiler';
+    public $template_lexer_class = 'Smarty_Internal_Templatelexer';
+    public $template_parser_class = 'Smarty_Internal_Templateparser';
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @return boolean true
+    */
+    public function isExisting($template)
+    {
+        if ($template->getTemplateSource() == '') {
+            return false;
+        } else {
+            return true;
+        } 
+    } 
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $_template template object
+    * @return string return 'string' as template source is not a file
+    */
+    public function getTemplateFilepath($_template)
+    { 
+        // no filepath for strings
+        // return resource name for compiler error messages
+        return str_replace(':', '://', $_template->template_resource);
+    } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $_template template object
+    * @return boolean false as string resources have no timestamp
+    */
+    public function getTemplateTimestamp($_template)
+    { 
+        // strings must always be compiled and have no timestamp
+        return false;
+    } 
+
+    /**
+    * Retuen template source from resource name
+    * 
+    * @param object $_template template object
+    * @return string content of template source
+    */
+    public function getTemplateSource($_template)
+    { 
+        // return template string
+        $_template->template_source = '';
+        $fp = fopen(str_replace(':', '://', $_template->template_resource),'r+');
+        while (!feof($fp)) {
+            $_template->template_source .= fgets($fp);
+        } 
+        fclose($fp);
+
+        return true;
+    } 
+
+    /**
+    * Return flag that this resource uses the compiler
+    * 
+    * @return boolean true
+    */
+    public function usesCompiler()
+    { 
+        // resource string is template, needs compiler
+        return true;
+    } 
+
+    /**
+    * Return flag that this resource is evaluated
+    * 
+    * @return boolean true
+    */
+    public function isEvaluated()
+    { 
+        // compiled template is evaluated instead of saved to disk
+        return true;
+    } 
+
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $_template template object
+    * @return boolean return false as compiled template is not stored
+    */
+    public function getCompiledFilepath($_template)
+    { 
+        // no filepath for strings
+        return false;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_resource_string.php

@@ -0,0 +1,109 @@
+<?php
+
+/**
+* Smarty Internal Plugin Resource String
+* 
+* Implements the strings as resource for Smarty template
+* 
+* @package Smarty
+* @subpackage TemplateResources
+* @author Uwe Tews 
+*/
+/**
+* Smarty Internal Plugin Resource String
+*/
+
+class Smarty_Internal_Resource_String {
+    public function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    // classes used for compiling Smarty templates from file resource
+    public $compiler_class = 'Smarty_Internal_SmartyTemplateCompiler';
+    public $template_lexer_class = 'Smarty_Internal_Templatelexer';
+    public $template_parser_class = 'Smarty_Internal_Templateparser';
+
+    /**
+    * Return flag if template source is existing
+    * 
+    * @return boolean true
+    */
+    public function isExisting($template)
+    {
+        return true;
+    } 
+
+    /**
+    * Get filepath to template source
+    * 
+    * @param object $_template template object
+    * @return string return 'string' as template source is not a file
+    */
+    public function getTemplateFilepath($_template)
+    { 
+        // no filepath for strings
+        // return "string" for compiler error messages
+        return 'string';
+    } 
+
+    /**
+    * Get timestamp to template source
+    * 
+    * @param object $_template template object
+    * @return boolean false as string resources have no timestamp
+    */
+    public function getTemplateTimestamp($_template)
+    { 
+        // strings must always be compiled and have no timestamp
+        return false;
+    } 
+
+    /**
+    * Retuen template source from resource name
+    * 
+    * @param object $_template template object
+    * @return string content of template source
+    */
+    public function getTemplateSource($_template)
+    { 
+        // return template string
+        $_template->template_source = $_template->resource_name;
+        return true;
+    } 
+
+    /**
+    * Return flag that this resource uses the compiler
+    * 
+    * @return boolean true
+    */
+    public function usesCompiler()
+    { 
+        // resource string is template, needs compiler
+        return true;
+    } 
+
+    /**
+    * Return flag that this resource is evaluated
+    * 
+    * @return boolean true
+    */
+    public function isEvaluated()
+    { 
+        // compiled template is evaluated instead of saved to disk
+        return true;
+    } 
+
+    /**
+    * Get filepath to compiled template
+    * 
+    * @param object $_template template object
+    * @return boolean return false as compiled template is not stored
+    */
+    public function getCompiledFilepath($_template)
+    { 
+        // no filepath for strings
+        return false;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_run_filter.php

@@ -0,0 +1,68 @@
+<?php
+
+/**
+* Smarty Internal Plugin Run Filter
+* 
+* Smarty run filter class
+* 
+* @package Smarty
+* @subpackage PluginsInternal
+* @author Uwe Tews 
+*/
+
+/**
+* Class for filter processing
+*/
+class Smarty_Internal_Run_Filter {
+    function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    /**
+    * Run filters over content
+    * 
+    * The filters will be lazy loaded if required
+    * class name format: Smarty_FilterType_FilterName
+    * plugin filename format: filtertype.filtername.php
+    * Smarty2 filter plugins could be used
+    * 
+    * @param string $type the type of filter ('pre','post','output' or 'variable') which shall run
+    * @param string $content the content which shall be processed by the filters
+    * @return string the filtered content
+    */
+    public function execute($type, $content, $flag = null)
+    {
+        $output = $content;
+        if ($type != 'variable' || ($this->smarty->variable_filter && $flag !== false) || $flag === true) {
+            // loop over autoload filters of specified type
+            if (!empty($this->smarty->autoload_filters[$type])) {
+                foreach ((array)$this->smarty->autoload_filters[$type] as $name) {
+                    $plugin_name = "Smarty_{$type}filter_{$name}";
+                    if ($this->smarty->loadPlugin($plugin_name)) {
+                        // use class plugin if found
+                        if (class_exists($plugin_name, false)) {
+                            // loaded class of filter plugin
+                            $output = call_user_func_array(array($plugin_name, 'execute'), array($output, $this->smarty));
+                        } elseif (function_exists($plugin_name)) {
+                            // use loaded Smarty2 style plugin
+                            $output = call_user_func_array($plugin_name, array($output, $this->smarty));
+                        } 
+                    } else {
+                        // nothing found, throw exception
+                        throw new Exception("Unable to load filter {$plugin_name}");
+                    } 
+                } 
+            } 
+            // loop over registerd filters of specified type
+            if (!empty($this->smarty->registered_filters[$type])) {
+                foreach ($this->smarty->registered_filters[$type] as $key => $name) {
+                    $output = call_user_func_array($this->smarty->registered_filters[$type][$key], array($output, $this->smarty));
+                } 
+            } 
+        } 
+        // return filtered output
+        return $output;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_security_handler.php

@@ -0,0 +1,130 @@
+<?php
+/**
+* Smarty Internal Plugin Security Handler
+* 
+* @package Smarty
+* @subpackage Security
+* @author Uwe Tews 
+*/
+/**
+* This class contains all methods for security checking
+*/
+class Smarty_Internal_Security_Handler {
+    function __construct($smarty)
+    {
+        $this->smarty = $smarty;
+    } 
+    /**
+    * Check if PHP function is trusted.
+    * 
+    * @param string $function_name 
+    * @param object $compiler compiler object
+    * @return boolean true if function is trusted
+    */
+    function isTrustedPhpFunction($function_name, $compiler)
+    {
+        if (empty($this->smarty->security_policy->php_functions) || in_array($function_name, $this->smarty->security_policy->php_functions)) {
+            return true;
+        } else {
+            $compiler->trigger_template_error ("PHP function \"" . $function_name . "\" not allowed by security setting");
+            return false;
+        } 
+    } 
+
+    /**
+    * Check if modifier is trusted.
+    * 
+    * @param string $modifier_name 
+    * @param object $compiler compiler object
+    * @return boolean true if modifier is trusted
+    */
+    function isTrustedModifier($modifier_name, $compiler)
+    {
+        if (empty($this->smarty->security_policy->modifiers) || in_array($modifier_name, $this->smarty->security_policy->modifiers)) {
+            return true;
+        } else {
+            $compiler->trigger_template_error ("modifier \"" . $modifier_name . "\" not allowed by security setting");
+            return false;
+        } 
+    } 
+    /**
+    * Check if stream is trusted.
+    * 
+    * @param string $stream_name 
+    * @param object $compiler compiler object
+    * @return boolean true if stream is trusted
+    */
+    function isTrustedStream($stream_name)
+    {
+        if (empty($this->smarty->security_policy->streams) || in_array($stream_name, $this->smarty->security_policy->streams)) {
+            return true;
+        } else {
+            throw new Exception ("stream \"" . $stream_name . "\" not allowed by security setting");
+            return false;
+        } 
+    } 
+
+    /**
+    * Check if directory of file resource is trusted.
+    * 
+    * @param string $filepath 
+    * @param object $compiler compiler object
+    * @return boolean true if directory is trusted
+    */
+    function isTrustedResourceDir($filepath)
+    {
+        $_rp = realpath($filepath);
+        if (isset($this->smarty->template_dir)) {
+            foreach ((array)$this->smarty->template_dir as $curr_dir) {
+                if (($_cd = realpath($curr_dir)) !== false &&
+                        strncmp($_rp, $_cd, strlen($_cd)) == 0 &&
+                        (strlen($_rp) == strlen($_cd) || substr($_rp, strlen($_cd), 1) == DS)) {
+                    return true;
+                } 
+            } 
+        } 
+        if (!empty($this->smarty->security_policy->secure_dir)) {
+            foreach ((array)$this->smarty->security_policy->secure_dir as $curr_dir) {
+                if (($_cd = realpath($curr_dir)) !== false) {
+                    if ($_cd == $_rp) {
+                        return true;
+                    } elseif (strncmp($_rp, $_cd, strlen($_cd)) == 0 &&
+                            (strlen($_rp) == strlen($_cd) || substr($_rp, strlen($_cd), 1) == DS)) {
+                        return true;
+                    } 
+                } 
+            } 
+        } 
+
+        throw new Exception ("directory \"" . $_rp . "\" not allowed by security setting");
+        return false;
+    } 
+    /**
+    * Check if directory of file resource is trusted.
+    * 
+    * @param string $filepath 
+    * @param object $compiler compiler object
+    * @return boolean true if directory is trusted
+    */
+    function isTrustedPHPDir($filepath)
+    {
+        $_rp = realpath($filepath);
+        if (!empty($this->smarty->security_policy->trusted_dir)) {
+            foreach ((array)$this->smarty->security_policy->trusted_dir as $curr_dir) {
+                if (($_cd = realpath($curr_dir)) !== false) {
+                    if ($_cd == $_rp) {
+                        return true;
+                    } elseif (strncmp($_rp, $_cd, strlen($_cd)) == 0 &&
+                            substr($_rp, strlen($_cd), 1) == DS) {
+                        return true;
+                    } 
+                } 
+            } 
+        } 
+
+        throw new Exception ("directory \"" . $_rp . "\" not allowed by security setting");
+        return false;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_smartytemplatecompiler.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+* Smarty Internal Plugin Smarty Template Compiler Base
+* 
+* This file contains the basic classes and methodes for compiling Smarty templates with lexer/parser
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Class SmartyTemplateCompiler
+*/
+class Smarty_Internal_SmartyTemplateCompiler extends Smarty_Internal_TemplateCompilerBase {
+    /**
+    * Initialize compiler
+    */
+    public function __construct($lexer_class, $parser_class, $smarty)
+    {
+        $this->smarty = $smarty;
+        parent::__construct(); 
+        // get required plugins
+//        $this->smarty->loadPlugin($lexer_class);
+//        $this->smarty->loadPlugin($parser_class);
+        $this->lexer_class = $lexer_class;
+        $this->parser_class = $parser_class;
+    } 
+
+    /**
+    * Methode to compile a Smarty template
+    * 
+    * @param  $_content template source
+    * @return bool true if compiling succeeded, false if it failed
+    */
+    protected function doCompile($_content)
+    {
+        /* here is where the compiling takes place. Smarty
+       tags in the templates are replaces with PHP code,
+       then written to compiled files. */ 
+        // init the lexer/parser to compile the template
+        $lex = new $this->lexer_class($_content,$this->smarty);
+        $parser = new $this->parser_class($lex, $this); 
+        // $parser->PrintTrace();
+        // get tokens from lexer and parse them
+        while ($lex->yylex() && !$this->abort_and_recompile) {
+            // echo "<br>Parsing  {$parser->yyTokenName[$lex->token]} Token {$lex->value} Line {$lex->line} \n";
+            $parser->doParse($lex->token, $lex->value);
+        } 
+
+        if ($this->abort_and_recompile) {
+            // exit here on abort
+            return false;
+        } 
+        // finish parsing process
+        $parser->doParse(0, 0); 
+        // check for unclosed tags
+        if (count($this->_tag_stack) > 0) {
+            // get stacked info
+            list($_open_tag, $_data) = array_pop($this->_tag_stack);
+            $this->trigger_template_error("unclosed {" . $_open_tag . "} tag");
+        } 
+
+        if (!$this->compile_error) {
+            // return compiled code
+            return str_replace(array("?>\n<?php","?><?php"), array('',''), $parser->retvalue);
+        } else {
+            // compilation error
+            return false;
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_template.php

@@ -0,0 +1,748 @@
+<?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 $resource_object = 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 $suppressFileDependency = 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;
+    private $cache_resource_object = null; 
+    // 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, $this->resource_object)) {
+            throw new Exception ("Unable to parse resource name \"{$template_resource}\"");
+        } 
+        // load cache resource
+        if (!$this->isEvaluated() && $this->caching) {
+            $this->cache_resource_object = 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->resource_object->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->resource_object->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->resource_object->getTemplateSource($this)) {
+                throw new Exception("Unable to read template {$this->resource_type} '{$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->resource_object->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->resource_object->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->resource_object->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->resource_object->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
+            $this->smarty->loadPlugin($this->resource_object->compiler_class);
+            $this->compiler_object = new $this->resource_object->compiler_class($this->resource_object->template_lexer_class, $this->resource_object->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);
+            } 
+        } 
+        // call compiler
+        if ($this->compiler_object->compileTemplate($this)) {
+            // compiling succeded
+            if (!$this->isEvaluated()) {
+                // write compiled template
+                Smarty_Internal_Write_File::writeFile($this->getCompiledFilepath(), $this->compiled_template); 
+                // make template and compiled file timestamp match
+                $this->compiled_timestamp = null;
+                touch($this->getCompiledFilepath(), $this->getTemplateTimestamp());
+                // daylight saving time problem on windows
+                if ($this->template_timestamp != $this->getCompiledTimestamp()) {
+                   touch($this->getCompiledFilepath(),2*$this->template_timestamp - $this->compiled_timestamp); 
+                }
+            } 
+        } 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->cache_resource_object->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->cache_resource_object->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->cache_resource_object->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->cache_resource_object->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_LIFETIME_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->cache_resource_object->getCachedContents($this);
+                    $this->cache_time += $this->_get_time() - $_start_time;
+                    if ($this->caching == SMARTY_CACHING_LIFETIME_SAVED && $this->properties['cache_lifetime'] >0 && (time() > ($this->getCachedTimestamp() + $this->properties['cache_lifetime']))) {
+                        $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) {
+                            $this->getResourceTypeName($_file_to_check[0], $resource_type, $resource_name);
+                            If ($resource_type == 'file') {
+                                $mtime = filemtime($_file_to_check[0]);
+                            } else {
+                                $resource_handler = $this->loadTemplateResourceHandler($resource_type);
+                                $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->compiled_template === null) {
+                $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) {
+                            $this->getResourceTypeName($_file_to_check[0], $resource_type, $resource_name);
+                            If ($resource_type == 'file') {
+                                $mtime = filemtime($_file_to_check[0]);
+                            } else {
+                                $resource_handler = $this->loadTemplateResourceHandler($resource_type);
+                                $mtime = $resource_handler->getTemplateTimestampTypeName($resource_type, $resource_name);
+                            } 
+                            If ($mtime != $_file_to_check[1]) {
+                                $this->properties['file_dependency'] = array();
+                                $this->mustCompile = true;
+                                break;
+                            } 
+                        } 
+                        if ($this->mustCompile) {
+                            // recompile and render again
+                            ob_get_clean();
+                            $this->compileTemplateSource();
+                            ob_start();
+                            include($this->getCompiledFilepath ());
+                        } 
+                    } 
+                } 
+            } 
+        } else {
+            if (is_callable(array($this->resource_object, 'renderUncompiled'))) {
+                $_start_time = $this->_get_time();
+                ob_start();
+                $this->resource_object->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->cache_resource_object->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
+    * Load required resource handler
+    * 
+    * @param string $template_resource template resource specification
+    * @param string $resource_type return resource type
+    * @param string $resource_name return resource name
+    * @param object $resource_handler return resource handler object
+    */
+    public function parseResourceName($template_resource, &$resource_type, &$resource_name, &$resource_handler)
+    {
+        if (empty($template_resource))
+            return false;
+        $this->getResourceTypeName($template_resource, $resource_type, $resource_name);
+        $resource_handler = $this->loadTemplateResourceHandler($resource_type); 
+        // cache template object under a unique ID
+        // do not cache string resources
+        // *****        if ($resource_type != 'string' && $this->smarty->caching) {
+        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;
+                    $this->parent->tpl_vars[$_key]->scope = SMARTY_LOCAL_SCOPE;
+                } 
+            } 
+            if ($scope == SMARTY_ROOT_SCOPE || $this->tpl_vars[$_key]->scope == SMARTY_ROOT_SCOPE) {
+                $_ptr = $this; 
+                // find  root
+                while ($_ptr->parent != null) {
+                    $_ptr = $_ptr->parent;
+                } 
+                if (isset($_ptr->tpl_vars[$_key])) {
+                    // variable is already defined in root, copy value
+                    $_ptr->tpl_vars[$_key]->value = $this->tpl_vars[$_key]->value;
+                } else {
+                    // create variable in root
+                    $_ptr->tpl_vars[$_key] = clone $_variable;
+                    $_ptr->tpl_vars[$_key]->scope = SMARTY_LOCAL_SCOPE;
+                } 
+            } 
+            if ($scope == SMARTY_GLOBAL_SCOPE || $this->tpl_vars[$_key]->scope == SMARTY_GLOBAL_SCOPE) {
+                if (isset($this->smarty->global_tpl_vars[$_key])) {
+                    // variable is already defined in root, copy value
+                    $this->smarty->global_tpl_vars[$_key]->value = $this->tpl_vars[$_key]->value;
+                } else {
+                    // create variable in root
+                    $this->smarty->global_tpl_vars[$_key] = clone $_variable;
+                } 
+                $this->smarty->global_tpl_vars[$_key]->scope = SMARTY_LOCAL_SCOPE;
+            } 
+        } 
+    } 
+
+    /**
+    * Split a template resource in its name and type
+    * 
+    * @param string $template_resource template resource specification
+    * @param string $resource_type return resource type
+    * @param string $resource_name return resource name
+    */
+    private function getResourceTypeName ($template_resource, &$resource_type, &$resource_name)
+    {
+        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 template resource handler by type
+    * 
+    * @param string $resource_type template resource type
+    * @return object resource handler object
+    */
+    private function loadTemplateResourceHandler ($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])) {
+                return $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)) {
+                    return $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)) {
+                        if (class_exists($_resource_class, false)) {
+                            return $this->smarty->resource_objects[$resource_type] = new $_resource_class($this->smarty);
+                        } else {
+                            $this->smarty->register_resource($resource_type,
+                                array("smarty_resource_{$resource_type}_source",
+                                    "smarty_resource_{$resource_type}_timestamp",
+                                    "smarty_resource_{$resource_type}_secure",
+                                    "smarty_resource_{$resource_type}_trusted"));
+                            return $this->smarty->resource_objects[$resource_type] = new Smarty_Internal_Resource_Registered($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);
+                            } 
+                            return $this->smarty->resource_objects[$resource_type] = new Smarty_Internal_Resource_Stream($this->smarty); 
+                        } else {
+                            throw new Exception('Unkown resource type \'' . $resource_type . '\'');
+                        } 
+                    } 
+                } 
+            } 
+        } else {
+            return $this->smarty->resource_objects[$resource_type];
+        } 
+    } 
+
+    /**
+    * Create property header
+    */
+    public function createPropertyHeader ()
+    {
+        $directory_security = $this->smarty->direct_access_security ? "<?php if(!defined('SMARTY_DIR')) exit('no direct access allowed'); ?>\n" : '';
+        $properties_string = "<?php \$_smarty_tpl->decodeProperties('" . str_replace("'", '"', (serialize($this->properties))) . "'); ?>\n";
+        return $directory_security . $properties_string;
+    } 
+
+    /**
+    * wrapper for display
+    */
+    public function display ()
+    {
+        return $this->smarty->display($this);
+    } 
+
+    /**
+    * wrapper for fetch
+    */
+    public function fetch ()
+    {
+        return $this->smarty->fetch($this);
+    } 
+    /**
+    * wrapper for is_cached
+    */
+    public function is_cached ()
+    {
+        return $this->iscached($this);
+    } 
+} 
+
+/**
+* wrapper for template class
+*/
+class Smarty_Template extends Smarty_Internal_Template {
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_templatebase.php

@@ -0,0 +1,431 @@
+<?php
+
+/**
+* Smarty Internal Plugin TemplateBase
+* 
+* This file contains the basic classes and methodes for template and variable creation
+* 
+* @package Smarty
+* @subpackage Templates
+* @author Uwe Tews 
+*/
+
+/**
+* Base class with template and variable methodes
+*/
+class Smarty_Internal_TemplateBase {
+    // class used for templates
+    public $template_class = 'Smarty_Internal_Template';
+
+    /**
+    * assigns a Smarty variable
+    * 
+    * @param array $ |string $tpl_var the template variable name(s)
+    * @param mixed $value the value to assign
+    * @param boolean $nocache if true any output of this variable will be not cached
+    * @param boolean $scope the scope the variable will have  (local,parent or root)
+    */
+    public function assign($tpl_var, $value = null, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
+    {
+        if (is_array($tpl_var)) {
+            foreach ($tpl_var as $_key => $_val) {
+                if ($_key != '') {
+                    $this->check_tplvar($_key);
+                    $this->tpl_vars[$_key] = new Smarty_variable($_val, $nocache, $scope);
+                } 
+            } 
+        } else {
+            if ($tpl_var != '') {
+                $this->check_tplvar($tpl_var);
+                $this->tpl_vars[$tpl_var] = new Smarty_variable($value, $nocache, $scope);
+            } 
+        } 
+    } 
+    /**
+    * assigns a global Smarty variable
+    * 
+    * @param string $varname the global variable name
+    * @param mixed $value the value to assign
+    * @param boolean $nocache if true any output of this variable will be not cached
+    */
+    public function assign_global($varname, $value = null, $nocache = false)
+    {
+        if ($varname != '') {
+            $this->check_tplvar($varname);
+            $this->smarty->global_tpl_vars[$varname] = new Smarty_variable($value, $nocache);
+        } 
+    } 
+    /**
+    * assigns values to template variables by reference
+    * 
+    * @param string $tpl_var the template variable name
+    * @param mixed $ &$value the referenced value to assign
+    * @param boolean $nocache if true any output of this variable will be not cached
+    * @param boolean $scope the scope the variable will have  (local,parent or root)
+    */
+    public function assign_by_ref($tpl_var, &$value, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
+    {
+        if ($tpl_var != '') {
+            $this->check_tplvar($tpl_var);
+            $this->tpl_vars[$tpl_var] = new Smarty_variable(null, $nocache, $scope);
+            $this->tpl_vars[$tpl_var]->value = &$value;
+        } 
+    } 
+    /**
+    * appends values to template variables
+    * 
+    * @param array $ |string $tpl_var the template variable name(s)
+    * @param mixed $value the value to append
+    * @param boolean $merge flag if array elements shall be merged
+    * @param boolean $nocache if true any output of this variable will be not cached
+    * @param boolean $scope the scope the variable will have  (local,parent or root)
+    */
+    public function append($tpl_var, $value = null, $merge = false, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
+    {
+        if (is_array($tpl_var)) {
+            // $tpl_var is an array, ignore $value
+            foreach ($tpl_var as $_key => $_val) {
+                if ($_key != '') {
+                    if (!isset($this->tpl_vars[$_key])) {
+                        $this->check_tplvar($_key);
+                        $tpl_var_inst = $this->getVariable($_key, null, true, false);
+                        if ($tpl_var_inst instanceof Undefined_Smarty_Variable) {
+                            $this->tpl_vars[$_key] = new Smarty_variable(null, $nocache, $scope);
+                        } else {
+                            $this->tpl_vars[$_key] = clone $tpl_var_inst;
+                            if ($scope != SMARTY_LOCAL_SCOPE) {
+                                $this->tpl_vars[$_key]->scope = $scope;
+                            } 
+                        } 
+                    } 
+                    if (!(is_array($this->tpl_vars[$_key]->value) || $this->tpl_vars[$_key]->value instanceof ArrayAccess)) {
+                        settype($this->tpl_vars[$_key]->value, 'array');
+                    } 
+                    if ($merge && is_array($_val)) {
+                        foreach($_val as $_mkey => $_mval) {
+                            $this->tpl_vars[$_key]->value[$_mkey] = $_mval;
+                        } 
+                    } else {
+                        $this->tpl_vars[$_key]->value[] = $_val;
+                    } 
+                } 
+            } 
+        } else {
+            if ($tpl_var != '' && isset($value)) {
+                if (!isset($this->tpl_vars[$tpl_var])) {
+                    $this->check_tplvar($tpl_var);
+                    $tpl_var_inst = $this->getVariable($tpl_var, null, true, false);
+                    if ($tpl_var_inst instanceof Undefined_Smarty_Variable) {
+                        $this->tpl_vars[$tpl_var] = new Smarty_variable(null, $nocache, $scope);
+                    } else {
+                        $this->tpl_vars[$tpl_var] = clone $tpl_var_inst;
+                        if ($scope != SMARTY_LOCAL_SCOPE) {
+                            $this->tpl_vars[$tpl_var]->scope = $scope;
+                        } 
+                    } 
+                } 
+                if (!(is_array($this->tpl_vars[$tpl_var]->value) || $this->tpl_vars[$tpl_var]->value instanceof ArrayAccess)) {
+                    settype($this->tpl_vars[$tpl_var]->value, 'array');
+                } 
+                if ($merge && is_array($value)) {
+                    foreach($value as $_mkey => $_mval) {
+                        $this->tpl_vars[$tpl_var]->value[$_mkey] = $_mval;
+                    } 
+                } else {
+                    $this->tpl_vars[$tpl_var]->value[] = $value;
+                } 
+            } 
+        } 
+    } 
+
+    /**
+    * appends values to template variables by reference
+    * 
+    * @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)
+    {
+        if ($tpl_var != '' && isset($value)) {
+            if (!isset($this->tpl_vars[$tpl_var])) {
+                $this->tpl_vars[$tpl_var] = new Smarty_variable();
+            } 
+            if (!@is_array($this->tpl_vars[$tpl_var]->value)) {
+                settype($this->tpl_vars[$tpl_var]->value, 'array');
+            } 
+            if ($merge && is_array($value)) {
+                foreach($value as $_key => $_val) {
+                    $this->tpl_vars[$tpl_var]->value[$_key] = &$value[$_key];
+                } 
+            } else {
+                $this->tpl_vars[$tpl_var]->value[] = &$value;
+            } 
+        } 
+    } 
+
+    /**
+    * check if template variable name is reserved.
+    * 
+    * @param string $tpl_var the template variable
+    */
+    private function check_tplvar($tpl_var)
+    {
+        if (in_array($tpl_var, array('this', 'smarty'))) {
+            throw new Exception("Cannot assign value to reserved var '{$tpl_var}'");
+        } 
+    } 
+
+    /**
+    * clear the given assigned template variable.
+    * 
+    * @param string $ |array $tpl_var the template variable(s) to clear
+    */
+    public function clear_assign($tpl_var)
+    {
+        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 all the assigned template variables.
+    */
+    public function clear_all_assign()
+    {
+        $this->tpl_vars = array();
+    } 
+
+    /**
+    * gets the object of a Smarty variable
+    * 
+    * @param string $variable the name of the Smarty variable
+    * @param object $_ptr optional pointer to data object
+    * @param boolean $search_parents search also in parent data
+    * @return object the object of the variable
+    */
+    public function getVariable($variable, $_ptr = null, $search_parents = true, $error_enable = true)
+    {
+        if ($_ptr === null) {
+            $_ptr = $this;
+        } while ($_ptr !== null) {
+            if (isset($_ptr->tpl_vars[$variable])) {
+                // found it, return it
+                return $_ptr->tpl_vars[$variable];
+            } 
+            // not found, try at parent
+            if ($search_parents) {
+                $_ptr = $_ptr->parent;
+            } else {
+                $_ptr = null;
+            } 
+        } 
+        if (isset($this->smarty->global_tpl_vars[$variable])) {
+            // found it, return it
+            return $this->smarty->global_tpl_vars[$variable];
+        } 
+        if ($this->smarty->error_unassigned && $error_enable) {
+            throw new Exception('Undefined Smarty variable "' . $variable . '"');
+        } else {
+            return new Undefined_Smarty_Variable;
+        } 
+    } 
+    /**
+    * gets  a config variable
+    * 
+    * @param string $variable the name of the config variable
+    * @return mixed the value of the config variable
+    */
+    public function getConfigVariable($variable)
+    {
+        $_ptr = $this;
+        while ($_ptr !== null) {
+            if (isset($_ptr->config_vars[$variable])) {
+                // found it, return it
+                return $_ptr->config_vars[$variable];
+            } 
+            // not found, try at parent
+            $_ptr = $_ptr->parent;
+        } 
+        if ($this->smarty->error_unassigned) {
+            throw new Exception('Undefined config variable "' . $variable . '"');
+        } else {
+            return '';
+        } 
+    } 
+    /**
+    * gets  a stream variable
+    * 
+    * @param string $variable the stream of the variable
+    * @return mixed the value of the stream variable
+    */
+    public function getStreamVariable($variable)
+    {
+        $_result = '';
+        if ($fp = fopen($variable, 'r+')) {
+            while (!feof($fp)) {
+                $_result .= fgets($fp);
+            } 
+            fclose($fp);
+            return $_result;
+        } 
+
+        if ($this->smarty->$error_unassigned) {
+            throw new Exception('Undefined stream variable "' . $variable . '"');
+        } else {
+            return '';
+        } 
+    } 
+
+    /**
+    * creates a template object
+    * 
+    * @param string $template the resource handle of the template file
+    * @param object $parent next higher level of Smarty variables
+    * @param mixed $cache_id cache id to be used with this template
+    * @param mixed $compile_id compile id to be used with this template
+    * @returns object template object
+    */
+    public function createTemplate($template, $cache_id = null, $compile_id = null, $parent = null)
+    {
+        if (is_object($cache_id) || is_array($cache_id)) {
+            $parent = $cache_id;
+            $cache_id = null;
+        } 
+        if (is_array($parent)) {
+            $data = $parent;
+            $parent = null;
+        } else {
+            $data = null;
+        } 
+        if (!is_object($template)) {
+            // we got a template resource
+            $_templateId = $this->buildTemplateId ($template, $cache_id, $compile_id); 
+            // already in template cache?
+            if (isset($this->smarty->template_objects[$_templateId]) && $this->smarty->caching) {
+                // return cached template object
+                $tpl = $this->smarty->template_objects[$_templateId];
+            } else {
+                // create new template object
+                $tpl = new $this->template_class($template, $this->smarty, $parent, $cache_id, $compile_id);
+            } 
+        } else {
+            // just return a copy of template class
+            $tpl = $template;
+        } 
+        // fill data if present
+        if (is_array($data)) {
+            // set up variable values
+            foreach ($data as $_key => $_val) {
+                $tpl->tpl_vars[$_key] = new Smarty_variable($_val);
+            } 
+        } 
+        return $tpl;
+    } 
+
+    /**
+    * generates a template id
+    * 
+    * @param string $_resource the resource handle of the template file
+    * @param mixed $_cache_id cache id to be used with this template
+    * @param mixed $_compile_id compile id to be used with this template
+    * @returns string a unique template id
+    */
+    function buildTemplateId ($_resource, $_cache_id, $_compile_id)
+    { 
+        // return md5($_resource . md5($_cache_id) . md5($_compile_id));
+        return crc32($_resource . $_cache_id . $_compile_id);
+    } 
+
+    /**
+    * return current time
+    * 
+    * @returns double current time
+    */
+    function _get_time()
+    {
+        $_mtime = microtime();
+        $_mtime = explode(" ", $_mtime);
+        return (double)($_mtime[1]) + (double)($_mtime[0]);
+    } 
+} 
+
+/**
+* class for the Smarty data object
+* 
+* The Smarty data object will hold Smarty variables in the current scope
+* 
+* @param object $parent tpl_vars next higher level of Smarty variables
+*/
+class Smarty_Data extends Smarty_Internal_TemplateBase {
+    // array of variable objects
+    public $tpl_vars = array(); 
+    // back pointer to parent object
+    public $parent = null; 
+    // config vars
+    public $config_vars = array();
+    /**
+    * create Smarty data object
+    */
+    public function __construct ($_parent = null)
+    {
+        if (is_object($_parent)) {
+            // when object set up back pointer
+            $this->parent = $_parent;
+        } elseif (is_array($_parent)) {
+            // set up variable values
+            foreach ($_parent as $_key => $_val) {
+                $this->tpl_vars[$_key] = new Smarty_variable($_val);
+            } 
+        } else {
+            throw new Exception("Wrong type for template variables");
+        } 
+    } 
+} 
+/**
+* class for the Smarty variable object
+* 
+* This class defines the Smarty variable object
+*/
+class Smarty_Variable {
+    // template variable
+    public $value;
+    public $nocache;
+    public $scope;
+    /**
+    * create Smarty variable object
+    * 
+    * @param mixed $value the value to assign
+    * @param boolean $nocache if true any output of this variable will be not cached
+    * @param boolean $scope the scope the variable will have  (local,parent or root)
+    */
+    public function __construct ($value = null, $nocache = false, $scope = SMARTY_LOCAL_SCOPE)
+    {
+        $this->value = $value;
+        $this->nocache = $nocache;
+        $this->scope = $scope;
+    } 
+} 
+
+/**
+* class for undefined variable object
+* 
+* This class defines an object for undefined variable handling
+*/
+class Undefined_Smarty_Variable {
+    // return always false
+    public function __get ($name)
+    {
+        if ($name == 'nocache') {
+            return false;
+        } else {
+            return null;
+        } 
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_templatecompilerbase.php

@@ -0,0 +1,269 @@
+<?php
+/**
+* Smarty Internal Plugin Smarty Template Compiler Base
+* 
+* This file contains the basic classes and methodes for compiling Smarty templates with lexer/parser
+* 
+* @package Smarty
+* @subpackage Compiler
+* @author Uwe Tews 
+*/
+/**
+* Main compiler class
+*/
+class Smarty_Internal_TemplateCompilerBase {
+    // compile tag objects
+    static $_tag_objects = array(); 
+    // tag stack
+    public $_tag_stack = array(); 
+    // current template
+    public $template = null;
+
+    /**
+    * Initialize compiler
+    */
+    public function __construct()
+    {
+    } 
+    // abstract function doCompile($_content);
+    /**
+    * Methode to compile a Smarty template
+    * 
+    * @param  $template template object to compile
+    * @return bool true if compiling succeeded, false if it failed
+    */
+    public function compileTemplate($template)
+    {
+        /* here is where the compiling takes place. Smarty
+       tags in the templates are replaces with PHP code,
+       then written to compiled files. */
+        if (!is_object($template->cacher_object)) {
+            $this->smarty->loadPlugin($template->cacher_class);
+            $template->cacher_object = new $template->cacher_class($this->smarty);
+        } 
+        // flag for nochache sections
+        $this->nocache = false;
+        $this->tag_nocache = false; 
+        // assume successfull compiling
+        $this->compile_error = false; 
+        // save template object in compiler class
+        $this->template = $template; 
+        // template header code
+        $template_header = '';
+        if (!$template->suppressHeader) {
+            $template_header .= "<?php /* Smarty version " . Smarty::$_version . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . "\n";
+            $template_header .= "         compiled from \"" . $this->template->getTemplateFilepath() . "\" */ ?>\n";
+        } 
+
+        do {
+            // flag for aborting current and start recompile
+            $this->abort_and_recompile = false; 
+            // get template source
+            $_content = $template->getTemplateSource(); 
+            // run prefilter if required
+            if (isset($this->smarty->autoload_filters['pre']) || isset($this->smarty->registered_filters['pre'])) {
+                $_content = $this->smarty->filter_handler->execute('pre', $_content);
+            } 
+            // on empty template just return header
+            if ($_content == '') {
+                if ($template->suppressFileDependency) {
+                    $template->compiled_template = '';
+                } else {
+                    $template->compiled_template = $template->createPropertyHeader() . $template_header;
+                } 
+                return true;
+            } 
+            // init cacher plugin
+            $template->cacher_object->initCacher($this); 
+            // call compiler
+            $_compiled_code = $this->doCompile($_content);
+        } while ($this->abort_and_recompile);
+
+        if (!$this->compile_error) {
+            // close cacher and return compiled template
+            if ($template->suppressFileDependency) {
+                $template->compiled_template = $template->cacher_object->closeCacher($this, $_compiled_code);
+            } else {
+                $template->compiled_template = $template->createPropertyHeader() . $template_header . $template->cacher_object->closeCacher($this, $_compiled_code);
+            } 
+            // run postfilter if required
+            if (isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) {
+                $template->compiled_template = $this->smarty->filter_handler->execute('post', $template->compiled_template);
+            } 
+            return true;
+        } else {
+            // compilation error
+            return false;
+        } 
+    } 
+
+    /**
+    * Compile Tag
+    * 
+    * This is a call back from the lexer/parser
+    * It executes the required compile plugin for the Smarty tag
+    * 
+    * @param string $tag tag name
+    * @param array $args array with tag attributes
+    * @return string compiled code
+    */
+    public function compileTag($tag, $args)
+    { 
+        // $args contains the attributes parsed and compiled by the lexer/parser
+        // assume that tag does compile into code, but creates no HTML output
+        $this->has_code = true;
+        $this->has_output = false; 
+        // compile the smarty tag (required compile classes to compile the tag are autoloaded)
+        if (($_output = $this->generateCode($tag, $args)) === false) {
+            if (isset($this->smarty->template_functions[$tag])) {
+                // template defined by {template} tag
+                $args['name'] = $tag;
+                $tag = 'function_call';
+                $_output = $this->generateCode($tag, $args);
+            } 
+        } 
+        if ($_output !== false) {
+            if ($_output !== true) {
+                // did we get compiled code
+                if ($this->has_code) {
+                    // Does it create output?
+                    if ($this->has_output) {
+                        $_output .= "\n";
+                    } 
+                    // return compiled code
+                    return $_output;
+                } 
+            } 
+            // tag did not produce compiled code
+            return '';
+        } else {
+            // not an internal compiler tag
+            // check if tag is a registered object
+            if (isset($this->smarty->registered_objects[$tag]) && isset($args['object_methode'])) {
+                $methode = $args['object_methode'];
+                unset ($args['object_methode']);
+                if (!in_array($methode, $this->smarty->registered_objects[$tag][3]) &&
+                        (empty($this->smarty->registered_objects[$tag][1]) || in_array($methode, $this->smarty->registered_objects[$tag][1]))) {
+                    return $this->generateCode('object_function',$args, $tag, $methode);
+                } elseif (in_array($methode, $this->smarty->registered_objects[$tag][3])) {
+                    return $this->generateCode('object_block_function',$args, $tag, $methode);
+                } else {
+                    return $this->trigger_template_error ('unallowed methode "' . $methode . '" in registered object "' . $tag . '"');
+                } 
+            } 
+            // check if tag is registered or is Smarty plugin
+            $this->smarty->plugin_handler->loadSmartyPlugin($tag, $this->smarty->plugin_search_order);
+            if (isset($this->smarty->registered_plugins[$tag])) {
+                // if compiler function plugin call it now
+                if ($this->smarty->registered_plugins[$tag][0] == 'compiler') {
+                    if (!$this->smarty->registered_plugins[$tag][2]) {
+                        $this->tag_nocache = true;
+                    } 
+                    return call_user_func($this->smarty->registered_plugins[$tag][1], $args, $this);
+                } 
+                // compile function or block plugin
+                $plugin_type = $this->smarty->registered_plugins[$tag][0] . '_plugin';
+                return $this->generateCode($plugin_type, $args, $tag);
+            } 
+            // compile closing tag of block function
+            if (strlen($tag) > 5 && substr_compare($tag, 'close', -5, 5) == 0) {
+                $base_tag = substr($tag, 0, -5); 
+                // check if closing tag is a registered object
+                if (isset($this->smarty->registered_objects[$base_tag]) && isset($args['object_methode'])) {
+                    $methode = $args['object_methode'];
+                    unset ($args['object_methode']);
+                    if (in_array($methode, $this->smarty->registered_objects[$base_tag][3])) {
+                        return $this->generateCode('object_block_function', $args, $tag, $methode);
+                    } else {
+                        return $this->trigger_template_error ('unallowed closing tag methode "' . $methode . '" in registered object "' . $base_tag . '"');
+                    } 
+                } 
+                // plugin ?
+                if (isset($this->smarty->registered_plugins[$base_tag]) && $this->smarty->registered_plugins[$base_tag][0] == 'block') {
+                    return $this->generateCode('block_plugin',$args, $tag);
+                } 
+            } 
+            $this->trigger_template_error ("unknown tag \"" . $tag . "\"");
+        } 
+    } 
+
+    /**
+    * lazy loads internal compile plugin for tag and calls the compile methode
+    * 
+    * compile objects cached for reuse.
+    * class name format:  Smarty_Internal_Compile_TagName
+    * plugin filename format: Smarty_Internal_Tagname.php
+    * 
+    * @param  $tag string tag name
+    * @param  $args array with tag attributes
+    * @param  $subtag optional tag name at plugins
+    * @param  $method string optional method on object tags
+    * @return string compiled code
+    */
+    public function generateCode($tag, $args, $subtag = null, $method = null)
+    { 
+        // re-use object if already exists
+        if (isset(self::$_tag_objects[$tag])) {
+            // compile this tag
+            return call_user_func(array(self::$_tag_objects[$tag], 'compile'), $args, $this, $subtag, $method);
+        } 
+        // lazy load internal compiler plugin
+        $class_name = 'Smarty_Internal_Compile_' . $tag;
+        if ($this->smarty->loadPlugin($class_name)) {
+            // use plugin if found
+            self::$_tag_objects[$tag] = new $class_name; 
+            // compile this tag
+            return call_user_func(array(self::$_tag_objects[$tag], 'compile'), $args, $this, $subtag, $method);
+        } 
+        // no internal compile plugin for this tag
+        return false;
+    } 
+
+    /**
+    * display compiler error messages without dying
+    * 
+    * If parameter $args is empty it is a parser detected syntax error.
+    * In this case the parser is called to obtain information about expected tokens.
+    * 
+    * If parameter $args contains a string this is used as error message
+    * 
+    * @todo output exact position of parse error in source line
+    * @param  $args string individual error message or null
+    */
+    public function trigger_template_error($args = null)
+    {
+        $this->lex = Smarty_Internal_Templatelexer::instance();
+        $this->parser = Smarty_Internal_Templateparser::instance(); 
+        // get template source line which has error
+        $line = $this->lex->line;
+        if (isset($args)) {
+            // $line--;
+        } 
+        $match = preg_split("/\n/", $this->lex->data);
+        $error_text = 'Syntax Error in template "' . $this->template->getTemplateFilepath() . '"  on line ' . $line . ' "' . $match[$line-1] . '" ';
+
+        if (isset($args)) {
+            // individual error message
+            $error_text .= $args;
+        } else {
+            // expected token from parser
+            foreach ($this->parser->yy_get_expected_tokens($this->parser->yymajor) as $token) {
+                $exp_token = $this->parser->yyTokenName[$token];
+                if (isset($this->lex->smarty_token_names[$exp_token])) {
+                    // token type from lexer
+                    $expect[] = '"' . $this->lex->smarty_token_names[$exp_token] . '"';
+                } else {
+                    // otherwise internal token name
+                    $expect[] = $this->parser->yyTokenName[$token];
+                } 
+            } 
+            // output parser error message
+            $error_text .= ' - Unexpected "' . $this->lex->value . '", expected one of: ' . implode(' , ', $expect);
+        } 
+        throw new Exception($error_text); 
+        // set error flag
+        $this->compile_error = true;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_internal_write_file.php

@@ -0,0 +1,47 @@
+<?php
+
+/**
+* Smarty write file plugin
+* 
+* @package Smarty
+* @subpackage PluginsInternal
+* @author Monte Ohrt 
+*/
+/**
+* Smarty Internal Write File Class
+*/
+class Smarty_Internal_Write_File {
+    /**
+    * Writes file in a save way to disk
+    * 
+    * @param string $_filepath complete filepath
+    * @param string $_contents file content
+    * @return boolean true
+    */
+    public static function writeFile($_filepath, $_contents)
+    {
+        $_dirpath = dirname($_filepath); 
+        // if subdirs, create dir structure
+        if ($_dirpath !== '.' && !file_exists($_dirpath)) {
+            mkdir($_dirpath, 0755, true);
+        } 
+        // write to tmp file, then move to overt file lock race condition
+        $_tmp_file = tempnam($_dirpath, 'wrt');
+
+        if (!file_put_contents($_tmp_file, $_contents)) {
+            throw new Exception("unable to write file {$_tmp_file}");
+            return false;
+        } 
+        // remove original file
+        if (file_exists($_filepath))
+            unlink($_filepath); 
+        // rename tmp file
+        rename($_tmp_file, $_filepath); 
+        // set file permissions
+        chmod($_filepath, 0644);
+
+        return true;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method__get_filter_name.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+* Smarty method _get_filter_name
+* 
+* Return internal filter name
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Return internal filter name
+* 
+* @param object $smarty 
+* @param callback $function 
+*/
+function _get_filter_name($smarty, $function)
+{
+		if (is_array($function)) {
+			$_class_name = (is_object($function[0]) ?
+				get_class($function[0]) : $function[0]);
+			return $_class_name . '_' . $function[1];
+		}
+		else {
+			return $function;
+		}
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_addpluginsdir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method addPluginsDir
+* 
+* Adds directory of plugin files
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Adds directory of plugin files
+* 
+* @param object $smarty 
+* @param string $ |array $ plugins folder
+* @return 
+*/
+function AddPluginsDir($smarty, $plugins_dir)
+{
+    $smarty->plugins_dir = array_merge((array)$smarty->plugins_dir, (array)$plugins_dir);
+    $smarty->plugins_dir = array_unique($smarty->plugins_dir);
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_all_assign.php

@@ -0,0 +1,29 @@
+<?php
+
+/**
+* Smarty method Clear_All_Assign
+* 
+* Deletes all assigned Smarty variables at current level
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Delete Smarty variables
+* 
+* @param object $smarty 
+* @param object $data_object object which holds tpl_vars
+*/
+function clear_all_assign($smarty, $data_object = null)
+{
+    if (isset($data_object)) {
+        $ptr = $data_object;
+    } else {
+        $ptr = $smarty;
+    } 
+    $ptr->tpl_vars = array();
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_all_cache.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+* Smarty method Clear_All_Cache
+* 
+* Empties the cache folder
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Empty cache folder
+* 
+* @param object $smarty 
+* @param integer $exp_time expiration time
+* @param string $type resource type
+* @return integer number of cache files deleted
+*/
+function clear_all_cache($smarty, $exp_time = null, $type = 'file')
+{ 
+    // load cache resource
+    if (!isset($smarty->cache_resource_objects[$type])) {
+        $_cache_resource_class = 'Smarty_Internal_CacheResource_' . $type;
+        if (!$smarty->loadPlugin($_cache_resource_class)) {
+            throw new Exception("Undefined cache resource type {$type}");
+        } 
+        $smarty->cache_resource_objects[$type] = new $_cache_resource_class($smarty);
+    } 
+
+    return $smarty->cache_resource_objects[$type]->clearAll($exp_time);
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_assign.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+* Smarty method Clear_Assign
+* 
+* Deletes a assigned Smarty variable or array of variables at current level
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Delete a Smarty variable or array of variables
+* 
+* @param object $smarty 
+* @param string $ |array $varname variable name or array of variable names
+* @param object $data_object object which holds tpl_vars
+*/
+function clear_assign($smarty, $varname, $data_object = null)
+{
+    foreach ((array)$varname as $variable) {
+        if (isset($data_object)) {
+            $ptr = $data_object;
+        } else {
+            $ptr = $smarty;
+        } while ($ptr != null) {
+            if (isset($ptr->tpl_vars[$variable])) {
+                unset($ptr->tpl_vars[$variable]);
+            } 
+            $ptr = $ptr->parent;
+        } 
+    } 
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_cache.php

@@ -0,0 +1,36 @@
+<?php
+
+/**
+* Smarty method Clear_Cache
+* 
+* Empties the cache for a specific template
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Empty cache for a specific template
+* 
+* @param object $smarty 
+* @param string $template_name template name
+* @param string $cache_id cache id
+* @param string $compile_id compile id
+* @param integer $exp_time expiration time
+* @param string $type resource type
+* @return integer number of cache files deleted
+*/
+function clear_cache($smarty, $template_name, $cache_id = null, $compile_id = null, $exp_time = null, $type = 'file')
+{ 
+    // load cache resource
+    $_cache_resource_class = 'Smarty_Internal_CacheResource_' . $type;
+    if (!$smarty->loadPlugin($_cache_resource_class)) {
+        throw new Exception("Undefined cache resource type {$type}");
+    } 
+    $cache_object = new $_cache_resource_class($smarty);
+
+    return $cache_object->clear($template_name, $cache_id, $compile_id, $exp_time);
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_compiled_tpl.php

@@ -0,0 +1,64 @@
+<?php
+
+/**
+* Smarty method Clear_Compiled_Tpl
+* 
+* Deletes compiled template files
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Delete compiled template file
+* 
+* @param string $resource_name template name
+* @param string $compile_id compile id
+* @param integer $exp_time expiration time
+* @return integer number of template files deleted
+*/
+function clear_compiled_tpl($smarty, $resource_name = null, $compile_id = null, $exp_time = null)
+{
+    $_dir_sep = $smarty->use_sub_dirs ? DS : '^';
+    if (isset($resource_name)) {
+        $_resource_part_1 = $resource_name . $smarty->php_ext;
+        $_resource_part_2 = $resource_name . '.cache' . $smarty->php_ext;
+    } else {
+        $_resource_part = '';
+    } 
+    $_dir = $smarty->compile_dir;
+    if ($smarty->use_sub_dirs && isset($compile_id)) {
+        $_dir .= $compile_id . $_dir_sep;
+    } 
+    if (isset($compile_id)) {
+        $_compile_id_part = $smarty->compile_dir . $compile_id . $_dir_sep;
+    } 
+    $_count = 0;
+    $_compileDirs = new RecursiveDirectoryIterator($_dir);
+    $_compile = new RecursiveIteratorIterator($_compileDirs, RecursiveIteratorIterator::CHILD_FIRST);
+    foreach ($_compile as $_file) {
+        if (strpos($_file, '.svn') !== false) continue;
+        if ($_file->isDir()) {
+            if (!$_compile->isDot()) {
+                // delete folder if empty
+                @rmdir($_file->getPathname());
+            } 
+        } else {
+            if ((!isset($compile_id) || substr_compare((string)$_file, $_compile_id_part, 0, strlen($_compile_id_part)) == 0) &&
+                    (!isset($resource_name) || substr_compare((string)$_file, $_resource_part_1, - strlen($_resource_part_1), strlen($_resource_part_1)) == 0 ||
+                        substr_compare((string)$_file, $_resource_part_2, - strlen($_resource_part_2), strlen($_resource_part_2)) == 0)) {
+                if (isset($exp_time)) {
+                    if (time() - @filemtime($_file) >= $exp_time) {
+                        $_count += unlink((string) $_file) ? 1 : 0;
+                    } 
+                } else {
+                    $_count += unlink((string) $_file) ? 1 : 0;
+                } 
+            } 
+        } 
+    } 
+    return $_count;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_clear_config.php

@@ -0,0 +1,30 @@
+<?php
+
+/**
+* Smarty method Get_Config_Vars
+* 
+* Returns a single or all global config variables
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Deassigns a single or all global config variables
+* 
+* @param object $smarty 
+* @param string $varname variable name or null
+*/
+function clear_config($smarty, $varname = null)
+{
+    if (isset($varname)) {
+        unset($smarty->config_vars[$varname]);
+        return;
+    } else {
+        $smarty->config_vars = array();
+        return;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_compile_directory.php

@@ -0,0 +1,72 @@
+<?php
+
+/**
+* Smarty method compile_dir
+* 
+* Compiles all template files in an given directory
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Compile all template files
+* 
+* @param string $dir_name name of directories
+* @return integer number of template files deleted
+*/
+function compile_directory($smarty, $extention = '.tpl', $force_compile = false, $time_limit = 0, $max_errors = null)
+{
+    function _get_time()
+    {
+        $_mtime = microtime();
+        $_mtime = explode(" ", $_mtime);
+        return (double)($_mtime[1]) + (double)($_mtime[0]);
+    } 
+    // set default directory
+    if ($dir_name === null) {
+        $dir_name = $smarty->template_dir;
+    } 
+    // switch off time limit
+    if (function_exists('set_time_limit')) {
+        @set_time_limit($time_limit);
+    } 
+    $smarty->force_compile = $force_compile;
+    $_count = 0;
+    $_error_count = 0; 
+    // loop over array of template directories
+    foreach((array)$smarty->template_dir as $_dir) {
+        $_compileDirs = new RecursiveDirectoryIterator($_dir);
+        $_compile = new RecursiveIteratorIterator($_compileDirs);
+        foreach ($_compile as $_fileinfo) {
+            if (strpos($_fileinfo, '.svn') !== false) continue;
+            $_file = $_fileinfo->getFilename();
+            if (!substr_compare($_file, $extention, - strlen($extention)) == 0) continue;
+            if ($_fileinfo->getPath() == substr($_dir, 0, -1)) {
+                $_template_file = $_file;
+            } else {
+                $_template_file = substr($_fileinfo->getPath(), strlen($_dir)) . '\\' . $_file;
+            } 
+            echo '<br>', $_dir, '---', $_template_file;
+            flush();
+            $_start_time = _get_time();
+            try {
+                $_tpl = $smarty->createTemplate($_template_file);
+                $_tpl->getCompiledTemplate();
+            } 
+            catch (Exception $e) {
+                echo 'Error: ', $e->getMessage(), "<br><br>";
+                $_error_count++;
+            } 
+            echo ' done in  ', _get_time() - $_start_time, ' seconds';
+            if ($max_errors !== null && $_error_count == $max_errors) {
+                echo '<br><br>too many errors';
+                exit();
+            } 
+        } 
+    } 
+    return $_count;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_config_load.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty methode Config_Load
+* 
+* Loads a config file
+* 
+* @package Smarty
+* @subpackage Config
+* @author Uwe Tews 
+*/
+
+/**
+* load a config file optionally load just selected sections
+* 
+* @param object $smarty 
+* @param string $config_file filename
+* @param mixed $sections array of section names, single section or null
+*/
+function config_load($smarty, $config_file, $sections = null)
+{ 
+    // load Config class
+    $config = new Smarty_Internal_Config($config_file, $smarty);
+    $config->loadConfigVars($sections, $smarty);
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disablecachemodifycheck.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+* Smarty method disableCacheModifyCheck
+* 
+* Disable cache modify check
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* 
+* Disable cache modify check
+*/
+function disableCacheModifyCheck($smarty)
+    {
+        $smarty->cache_modified_check = false;
+        return ;
+    } 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disablecaching.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableCaching
+* 
+* Disable caching
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable caching
+*/
+function DisableCaching()
+{
+    $this->smarty->caching = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disablecompilecheck.php

@@ -0,0 +1,24 @@
+<?php
+
+/**
+* Smarty method disableCompileCheck
+* 
+* Disable compile checking
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable compile checking
+* 
+* @param object $smarty 
+*/
+function DisableCompileCheck($smarty)
+{
+    $smarty->compile_check = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disableconfigbooleanize.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableConfigBooleanize
+* 
+* Disable config booleanize mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable config booleanize mode
+*/
+function disableConfigBooleanize($smarty)
+{
+    $this->smarty->config_booleanize = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disableconfigoverwrite.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method disableConfigOverwrite
+* 
+* Disable config overwrite mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable config overwrite mode
+*/
+function disableConfigOverwrite($smarty)
+{
+    $smarty->config_overwrite = false;
+    return ;
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disableconfigreadhidden.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method disableConfigReadHidden
+* 
+* Disable config read hidden mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable config read hidden mode
+*/
+function disableConfigReadHidden ($smarty)
+{
+    $this->smarty->config_read_hidden = false;
+    return;
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disabledebugging.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method disableDebugging
+* 
+* Disable debugging
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable debugging
+*/
+function disableDebugging($smarty)
+{
+    $smarty->debugging = false;
+    return;
+} 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disabledebuggingurlctrl.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableDebuggingUrlCtrl
+* 
+* Disable possibility to Disable debugging by SMARTY_DEBUG attribute
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable possibility to Disable debugging by SMARTY_DEBUG attribute
+*/
+function disableDebuggingUrlCtrl($smarty)
+    {
+        $smarty->debugging_ctrl = 'none';
+        return;
+    } 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disabledefaulttimezone.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableDefaultTimezone
+* 
+* Disable setting of default timezone
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable setting of default timezone
+*/
+function disableDefaultTimezone($smarty)
+{
+    $smarty->set_timezone = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disableforcecompile.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableForceCompile
+* 
+* Disable forced compiling
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable forced compiling
+*/
+function disableForceCompile($smarty)
+{
+    $smarty->force_compile = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_disablevariablefilter.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method disableVariableFilter
+* 
+* Disable  filter on variable output
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Disable filter on variable output
+*/
+function disableVariableFilter($smarty)
+{
+    $smarty->variable_filter = false;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enablecachemodifycheck.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableCacheModifyCheck
+* 
+* Enable cache modify check
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable cache modify check
+*/
+function enableCacheModifyCheck($smarty)
+{
+    $smarty->cache_modified_check = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enablecompilecheck.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableCompileCheck
+* 
+* Enable compile checking
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable compile checking
+*/
+function enableCompileCheck($smarty)
+{
+    $smarty->compile_check = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enableconfigbooleanize.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableConfigBooleanize
+* 
+* Enable config booleanize mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable config booleanize mode
+*/
+function enableConfigBooleanize($smarty)
+{
+    $smarty->config_booleanize = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enableconfigoverwrite.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableConfigOverwrite
+* 
+* Enable config overwrite mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable config overwrite mode
+*/
+function enableConfigOverwrite($smarty)
+{
+    $smarty->config_overwrite = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enableconfigreadhidden.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableConfigReadHidden
+* 
+* Enable config read hidden mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable config read hidden mode
+*/
+function enableConfigReadHidden($smarty)
+{
+    $this->smarty->config_read_hidden = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enabledebugging.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableDebugging
+* 
+* Enable debugging
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable debugging
+*/
+function enableDebugging($smarty)
+{
+    $this->smarty->debugging = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enabledebuggingurlctrl.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableDebuggingUrlCtrl
+* 
+* Enable possibility to enable debugging by SMARTY_DEBUG attribute
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable possibility to enable debugging by SMARTY_DEBUG attribute
+*/
+function enableDebuggingUrlCtrl($smarty)
+{
+    $smarty->debugging_ctrl = 'URL';
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enabledefaulttimezone.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableDefaultTimezone
+* 
+* Enable setting of default timezone
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable setting of default timezone
+*/
+function enableDefaultTimezone($smarty)
+{
+    $this->smarty->set_timezone = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enableforcecompile.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableForceCompile
+* 
+* Enable forced compiling
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable forced compiling
+*/
+function enableForceCompile($smarty)
+{
+    $smarty->force_compile = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_enablevariablefilter.php

@@ -0,0 +1,22 @@
+<?php
+
+/**
+* Smarty method enableVariableFilter
+* 
+* Enable  filter on variable output
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Enable filter on variable output
+*/
+function enableVariableFilter($smarty)
+{
+    $smarty->variable_filter = true;
+    return;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_get_config_vars.php

@@ -0,0 +1,36 @@
+<?php
+
+/**
+* Smarty method Get_Config_Vars
+* 
+* Returns a single or all global config variables
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns a single or all global config variables
+*/
+
+/**
+* Returns a single or all global config variables
+* 
+* @param string $varname variable name or null
+* @return string variable value or or array of variables
+*/
+function Get_Config_Vars($smarty, $varname = null)
+{
+    if (isset($varname)) {
+        if (isset($smarty->config_vars[$varname])) {
+            return $smarty->config_vars[$varname];
+        } else {
+            return '';
+        } 
+    } else {
+        return $smarty->config_vars;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_get_global.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+* Smarty method Get_Global
+* 
+* Returns a single or all global variables
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns a single or all global  variables
+* 
+* @param object $smarty 
+* @param string $varname variable name or null
+* @return string variable value or or array of variables
+*/
+function get_global($smarty, $varname = null)
+{
+    if (isset($varname)) {
+        if (isset($smarty->global_tpl_vars[$varname])) {
+            return $smarty->global_tpl_vars[$varname]->value;
+        } else {
+            return '';
+        } 
+    } else {
+        $_result = array();
+        foreach ($smarty->global_tpl_vars AS $key => $var) {
+            $_result[$key] = $var->value;
+        } 
+        return $_result;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_get_registered_object.php

@@ -0,0 +1,34 @@
+<?php
+
+/**
+* Smarty method Get_Registered_Object
+* 
+* Registers a PHP object
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns a reference to a registered object
+*/
+
+/**
+* return a reference to a registered object
+* 
+* @param string $name 
+* @return object 
+*/
+function get_registered_object($smarty, $name)
+{
+    if (!isset($smarty->registered_objects[$name]))
+        throw new Exception("'$name' is not a registered object");
+
+    if (!is_object($smarty->registered_objects[$name][0]))
+        throw new Exception("registered '$name' is not an object");
+
+    return $smarty->registered_objects[$name][0];
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_get_template_vars.php

@@ -0,0 +1,56 @@
+<?php
+
+/**
+* Smarty method Get_Template_Vars
+* 
+* Returns a single or all template variables
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns a single or all template variables
+*/
+
+/**
+* Returns a single or all template variables
+* 
+* @param string $varname variable name or null
+* @return string variable value or or array of variables
+*/
+function get_template_vars($smarty, $varname = null, $_ptr = null, $search_parents = true)
+{
+    if (isset($varname)) {
+        $_var = $smarty->getVariable($varname, $_ptr, $search_parents);
+        if (is_object($_var)) {
+            return $_var->value;
+        } else {
+            return null;
+        } 
+    } else {
+        $_result = array();
+        if ($_ptr === null) {
+            $_ptr = $smarty;
+        } while ($_ptr !== null) {
+            foreach ($_ptr->tpl_vars AS $key => $var) {
+                $_result[$key] = $var->value;
+            } 
+            // not found, try at parent
+            if ($search_parents) {
+                $_ptr = $_ptr->parent;
+            } else {
+                $_ptr = null;
+            } 
+        } 
+        if ($search_parents) {
+            foreach ($smarty->global_tpl_vars AS $key => $var) {
+                $_result[$key] = $var->value;
+            } 
+        } 
+        return $_result;
+    } 
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getcachedir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getCacheDir
+* 
+* Returns directory of cache files
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns directory of cache files
+*/
+
+/**
+* Returns directory of cache files
+* 
+* @return array cache folder
+*/
+function getCacheDir($smarty)
+{
+    return $this->smarty->cache_dir;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getcachelifetime.php

@@ -0,0 +1,28 @@
+<?php
+
+/**
+* Smarty method getCacheLifetime
+* 
+* Returns lifetime of cache files
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Smarty class getCacheLifetime
+* 
+* Returns lifetime of cache files
+*/
+/**
+* Returns lifetime of cache files
+* 
+* @return integer cache file lifetime
+*/
+function getCacheLifetime($smarty)
+{
+    return $smarty->cache_lifetime;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getcompiledir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getCompileDir
+* 
+* Returns directory of compiled templates
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns directory of compiled templates
+*/
+
+/**
+* Returns directory of compiled templates
+* 
+* @return array compiled template folder
+*/
+function GetCompileDir($smarty)
+{
+    return $this->smarty->compile_dir;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getconfigdir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getConfigDir
+* 
+* Returns directory of config files
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns directory of config files
+*/
+
+/**
+* Returns directory of config files
+* 
+* @return array config folder
+*/
+function getConfigDir($smarty)
+{
+    return $smarty->config_dir;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getdebugtemplate.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getDebugTemplate
+* 
+* Returns debug template filepath
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns debug template filepath
+*/
+
+/**
+* Returns directory of cache files
+* 
+* @return string debug template filepath
+*/
+function GetDebugTemplate($smarty)
+{
+    return $smarty->debug_tpl;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getpluginsdir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getPluginsDir
+* 
+* Returns directory of plugins
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns directory of plugins
+*/
+
+/**
+* Returns directory of plugins
+* 
+* @return array plugins folder
+*/
+function getPluginsDir($smarty)
+{
+    return $smarty->plugins_dir;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_gettemplatedir.php

@@ -0,0 +1,27 @@
+<?php
+
+/**
+* Smarty method getTemplateDir
+* 
+* Returns template directory
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Returns template directory
+*/
+
+/**
+* Returns template directory
+* 
+* @return array template folders
+*/
+function getTemplateDir($smarty)
+{
+    return $smarty->template_dir;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_getvariablefilter.php

@@ -0,0 +1,23 @@
+<?php
+
+/**
+* Smarty method getVariableFilter
+* 
+* get status of filter on variable output
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* Smarty class getVariableFilter
+* 
+* get status of filter on variable output
+*/
+function getVariableFilter($smarty)
+{
+    return $smarty->variable_filter;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_iscachemodifycheck.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isCacheModifyCheck
+* 
+* is cache modify check
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is cache modify check
+*/
+function isCacheModifyCheck()
+{
+    return $smarty->cache_modified_check;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_iscaching.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isCaching
+* 
+* is caching
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is caching
+*/
+function isCaching($smarty)
+{
+    return $smarty->caching;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_iscompilecheck.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isCompileCheck
+* 
+* is compile checking
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is compile checking
+*/
+function isCompileCheck($smarty)
+{
+    return $smarty->compile_check;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_isconfigbooleanize.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isConfigBooleanize
+* 
+* is config booleanize mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is config booleanize mode
+*/
+function isConfigBooleanize($smarty)
+{
+    return $smarty->config_booleanize;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_isconfigoverwrite.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isConfigOverwrite
+* 
+* is config overwrite mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is config overwrite mode
+*/
+function isConfigOverwrite($smarty)
+{
+    return $smarty->config_overwrite;
+} 
+
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_isconfigreadhidden.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isConfigReadHidden
+* 
+* is config read hidden mode
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* 
+* is config read hidden mode
+*/
+function isConfigReadHidden($smarty)
+    {
+        return $smarty->config_read_hidden;
+    } 
+?>

onyx2/modules/templates/smarty/sysplugins/smarty_method_isdebugging.php

@@ -0,0 +1,21 @@
+<?php
+
+/**
+* Smarty method isDebugging
+* 
+* is debugging
+* 
+* @package Smarty
+* @subpackage SmartyMethod
+* @author Uwe Tews 
+*/
+
+/**
+* is debugging
+*/
+function isDebugging($smarty)
+{
+    return $smarty->debugging;
+} 
+
+?>