gosa-core/include/smarty/Smarty_Compiler.class.php

   1 <?php
   2
   3 /**
   4  * Project:     Smarty: the PHP compiling template engine
   5  * File:        Smarty_Compiler.class.php
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * @link http://smarty.php.net/
  22  * @author Monte Ohrt <monte at ohrt dot com>
  23  * @author Andrei Zmievski <andrei@php.net>
  24  * @version 2.6.19
  25  * @copyright 2001-2005 New Digital Group, Inc.
  26  * @package Smarty
  27  */
  28
  29 /* $Id: Smarty_Compiler.class.php 2736 2007-09-16 14:47:53Z mohrt $ */
  30
  31 /**
  32  * Template compiling class
  33  * @package Smarty
  34  */
  35 class Smarty_Compiler extends Smarty {
  36
  37     // internal vars
  38     /**#@+
  39      * @access private
  40      */
  41     var $_folded_blocks         =   array();    // keeps folded template blocks
  42     var $_current_file          =   null;       // the current template being compiled
  43     var $_current_line_no       =   1;          // line number for error messages
  44     var $_capture_stack         =   array();    // keeps track of nested capture buffers
  45     var $_plugin_info           =   array();    // keeps track of plugins to load
  46     var $_init_smarty_vars      =   false;
  47     var $_permitted_tokens      =   array('true','false','yes','no','on','off','null');
  48     var $_db_qstr_regexp        =   null;        // regexps are setup in the constructor
  49     var $_si_qstr_regexp        =   null;
  50     var $_qstr_regexp           =   null;
  51     var $_func_regexp           =   null;
  52     var $_reg_obj_regexp        =   null;
  53     var $_var_bracket_regexp    =   null;
  54     var $_num_const_regexp      =   null;
  55     var $_dvar_guts_regexp      =   null;
  56     var $_dvar_regexp           =   null;
  57     var $_cvar_regexp           =   null;
  58     var $_svar_regexp           =   null;
  59     var $_avar_regexp           =   null;
  60     var $_mod_regexp            =   null;
  61     var $_var_regexp            =   null;
  62     var $_parenth_param_regexp  =   null;
  63     var $_func_call_regexp      =   null;
  64     var $_obj_ext_regexp        =   null;
  65     var $_obj_start_regexp      =   null;
  66     var $_obj_params_regexp     =   null;
  67     var $_obj_call_regexp       =   null;
  68     var $_cacheable_state       =   0;
  69     var $_cache_attrs_count     =   0;
  70     var $_nocache_count         =   0;
  71     var $_cache_serial          =   null;
  72     var $_cache_include         =   null;
  73
  74     var $_strip_depth           =   0;
  75     var $_additional_newline    =   "\n";
  76
  77     /**#@-*/
  78     /**
  79      * The class constructor.
  80      */
  81     function Smarty_Compiler()
  82     {
  83         // matches double quoted strings:
  84         // "foobar"
  85         // "foo\"bar"
  86         $this->_db_qstr_regexp = '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"';
  87
  88         // matches single quoted strings:
  89         // 'foobar'
  90         // 'foo\'bar'
  91         $this->_si_qstr_regexp = '\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'';
  92
  93         // matches single or double quoted strings
  94         $this->_qstr_regexp = '(?:' . $this->_db_qstr_regexp . '|' . $this->_si_qstr_regexp . ')';
  95
  96         // matches bracket portion of vars
  97         // [0]
  98         // [foo]
  99         // [$bar]
 100         $this->_var_bracket_regexp = '\[\$?[\w\.]+\]';
 101
 102         // matches numerical constants
 103         // 30
 104         // -12
 105         // 13.22
 106         $this->_num_const_regexp = '(?:\-?\d+(?:\.\d+)?)';
 107
 108         // matches $ vars (not objects):
 109         // $foo
 110         // $foo.bar
 111         // $foo.bar.foobar
 112         // $foo[0]
 113         // $foo[$bar]
 114         // $foo[5][blah]
 115         // $foo[5].bar[$foobar][4]
 116         $this->_dvar_math_regexp = '(?:[\+\*\/\%]|(?:-(?!>)))';
 117         $this->_dvar_math_var_regexp = '[\$\w\.\+\-\*\/\%\d\>\[\]]';
 118         $this->_dvar_guts_regexp = '\w+(?:' . $this->_var_bracket_regexp
 119                 . ')*(?:\.\$?\w+(?:' . $this->_var_bracket_regexp . ')*)*(?:' . $this->_dvar_math_regexp . '(?:' . $this->_num_const_regexp . '|' . $this->_dvar_math_var_regexp . ')*)?';
 120         $this->_dvar_regexp = '\$' . $this->_dvar_guts_regexp;
 121
 122         // matches config vars:
 123         // #foo#
 124         // #foobar123_foo#
 125         $this->_cvar_regexp = '\#\w+\#';
 126
 127         // matches section vars:
 128         // %foo.bar%
 129         $this->_svar_regexp = '\%\w+\.\w+\%';
 130
 131         // matches all valid variables (no quotes, no modifiers)
 132         $this->_avar_regexp = '(?:' . $this->_dvar_regexp . '|'
 133            . $this->_cvar_regexp . '|' . $this->_svar_regexp . ')';
 134
 135         // matches valid variable syntax:
 136         // $foo
 137         // $foo
 138         // #foo#
 139         // #foo#
 140         // "text"
 141         // "text"
 142         $this->_var_regexp = '(?:' . $this->_avar_regexp . '|' . $this->_qstr_regexp . ')';
 143
 144         // matches valid object call (one level of object nesting allowed in parameters):
 145         // $foo->bar
 146         // $foo->bar()
 147         // $foo->bar("text")
 148         // $foo->bar($foo, $bar, "text")
 149         // $foo->bar($foo, "foo")
 150         // $foo->bar->foo()
 151         // $foo->bar->foo->bar()
 152         // $foo->bar($foo->bar)
 153         // $foo->bar($foo->bar())
 154         // $foo->bar($foo->bar($blah,$foo,44,"foo",$foo[0].bar))
 155         $this->_obj_ext_regexp = '\->(?:\$?' . $this->_dvar_guts_regexp . ')';
 156         $this->_obj_restricted_param_regexp = '(?:'
 157                 . '(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . ')(?:' . $this->_obj_ext_regexp . '(?:\((?:(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . ')'
 158                 . '(?:\s*,\s*(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . '))*)?\))?)*)';
 159         $this->_obj_single_param_regexp = '(?:\w+|' . $this->_obj_restricted_param_regexp . '(?:\s*,\s*(?:(?:\w+|'
 160                 . $this->_var_regexp . $this->_obj_restricted_param_regexp . ')))*)';
 161         $this->_obj_params_regexp = '\((?:' . $this->_obj_single_param_regexp
 162                 . '(?:\s*,\s*' . $this->_obj_single_param_regexp . ')*)?\)';
 163         $this->_obj_start_regexp = '(?:' . $this->_dvar_regexp . '(?:' . $this->_obj_ext_regexp . ')+)';
 164         $this->_obj_call_regexp = '(?:' . $this->_obj_start_regexp . '(?:' . $this->_obj_params_regexp . ')?(?:' . $this->_dvar_math_regexp . '(?:' . $this->_num_const_regexp . '|' . $this->_dvar_math_var_regexp . ')*)?)';
 165
 166         // matches valid modifier syntax:
 167         // |foo
 168         // |@foo
 169         // |foo:"bar"
 170         // |foo:$bar
 171         // |foo:"bar":$foobar
 172         // |foo|bar
 173         // |foo:$foo->bar
 174         $this->_mod_regexp = '(?:\|@?\w+(?::(?:\w+|' . $this->_num_const_regexp . '|'
 175            . $this->_obj_call_regexp . '|' . $this->_avar_regexp . '|' . $this->_qstr_regexp .'))*)';
 176
 177         // matches valid function name:
 178         // foo123
 179         // _foo_bar
 180         $this->_func_regexp = '[a-zA-Z_]\w*';
 181
 182         // matches valid registered object:
 183         // foo->bar
 184         $this->_reg_obj_regexp = '[a-zA-Z_]\w*->[a-zA-Z_]\w*';
 185
 186         // matches valid parameter values:
 187         // true
 188         // $foo
 189         // $foo|bar
 190         // #foo#
 191         // #foo#|bar
 192         // "text"
 193         // "text"|bar
 194         // $foo->bar
 195         $this->_param_regexp = '(?:\s*(?:' . $this->_obj_call_regexp . '|'
 196            . $this->_var_regexp . '|' . $this->_num_const_regexp  . '|\w+)(?>' . $this->_mod_regexp . '*)\s*)';
 197
 198         // matches valid parenthesised function parameters:
 199         //
 200         // "text"
 201         //    $foo, $bar, "text"
 202         // $foo|bar, "foo"|bar, $foo->bar($foo)|bar
 203         $this->_parenth_param_regexp = '(?:\((?:\w+|'
 204                 . $this->_param_regexp . '(?:\s*,\s*(?:(?:\w+|'
 205                 . $this->_param_regexp . ')))*)?\))';
 206
 207         // matches valid function call:
 208         // foo()
 209         // foo_bar($foo)
 210         // _foo_bar($foo,"bar")
 211         // foo123($foo,$foo->bar(),"foo")
 212         $this->_func_call_regexp = '(?:' . $this->_func_regexp . '\s*(?:'
 213            . $this->_parenth_param_regexp . '))';
 214     }
 215
 216     /**
 217      * compile a resource
 218      *
 219      * sets $compiled_content to the compiled source
 220      * @param string $resource_name
 221      * @param string $source_content
 222      * @param string $compiled_content
 223      * @return true
 224      */
 225     function _compile_file($resource_name, $source_content, &$compiled_content)
 226     {
 227
 228         if ($this->security) {
 229             // do not allow php syntax to be executed unless specified
 230             if ($this->php_handling == SMARTY_PHP_ALLOW &&
 231                 !$this->security_settings['PHP_HANDLING']) {
 232                 $this->php_handling = SMARTY_PHP_PASSTHRU;
 233             }
 234         }
 235
 236         $this->_load_filters();
 237
 238         $this->_current_file = $resource_name;
 239         $this->_current_line_no = 1;
 240         $ldq = preg_quote($this->left_delimiter, '~');
 241         $rdq = preg_quote($this->right_delimiter, '~');
 242
 243         // run template source through prefilter functions
 244         if (count($this->_plugins['prefilter']) > 0) {
 245             foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
 246                 if ($prefilter === false) continue;
 247                 if ($prefilter[3] || is_callable($prefilter[0])) {
 248                     $source_content = call_user_func_array($prefilter[0],
 249                                                             array($source_content, &$this));
 250                     $this->_plugins['prefilter'][$filter_name][3] = true;
 251                 } else {
 252                     $this->_trigger_fatal_error("[plugin] prefilter '$filter_name' is not implemented");
 253                 }
 254             }
 255         }
 256
 257         /* fetch all special blocks */
 258         $search = "~{$ldq}\*(.*?)\*{$rdq}|{$ldq}\s*literal\s*{$rdq}(.*?){$ldq}\s*/literal\s*{$rdq}|{$ldq}\s*php\s*{$rdq}(.*?){$ldq}\s*/php\s*{$rdq}~s";
 259
 260         preg_match_all($search, $source_content, $match,  PREG_SET_ORDER);
 261         $this->_folded_blocks = $match;
 262         reset($this->_folded_blocks);
 263
 264         /* replace special blocks by "{php}" */
 265         $source_content = preg_replace($search.'e', "'"
 266                                        . $this->_quote_replace($this->left_delimiter) . 'php'
 267                                        . "' . str_repeat(\"\n\", substr_count('\\0', \"\n\")) .'"
 268                                        . $this->_quote_replace($this->right_delimiter)
 269                                        . "'"
 270                                        , $source_content);
 271
 272         /* Gather all template tags. */
 273         preg_match_all("~{$ldq}\s*(.*?)\s*{$rdq}~s", $source_content, $_match);
 274         $template_tags = $_match[1];
 275         /* Split content by template tags to obtain non-template content. */
 276         $text_blocks = preg_split("~{$ldq}.*?{$rdq}~s", $source_content);
 277
 278         /* loop through text blocks */
 279         for ($curr_tb = 0, $for_max = count($text_blocks); $curr_tb < $for_max; $curr_tb++) {
 280             /* match anything resembling php tags */
 281             if (preg_match_all('~(<\?(?:\w+|=)?|\?>|language\s*=\s*[\"\']?\s*php\s*[\"\']?)~is', $text_blocks[$curr_tb], $sp_match)) {
 282                 /* replace tags with placeholders to prevent recursive replacements */
 283                 $sp_match[1] = array_unique($sp_match[1]);
 284                 usort($sp_match[1], '_smarty_sort_length');
 285                 for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
 286                     $text_blocks[$curr_tb] = str_replace($sp_match[1][$curr_sp],'%%%SMARTYSP'.$curr_sp.'%%%',$text_blocks[$curr_tb]);
 287                 }
 288                 /* process each one */
 289                 for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
 290                     if ($this->php_handling == SMARTY_PHP_PASSTHRU) {
 291                         /* echo php contents */
 292                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', '<?php echo \''.str_replace("'", "\'", $sp_match[1][$curr_sp]).'\'; ?>'."\n", $text_blocks[$curr_tb]);
 293                     } else if ($this->php_handling == SMARTY_PHP_QUOTE) {
 294                         /* quote php tags */
 295                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', htmlspecialchars($sp_match[1][$curr_sp]), $text_blocks[$curr_tb]);
 296                     } else if ($this->php_handling == SMARTY_PHP_REMOVE) {
 297                         /* remove php tags */
 298                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', '', $text_blocks[$curr_tb]);
 299                     } else {
 300                         /* SMARTY_PHP_ALLOW, but echo non php starting tags */
 301                         $sp_match[1][$curr_sp] = preg_replace('~(<\?(?!php|=|$))~i', '<?php echo \'\\1\'?>'."\n", $sp_match[1][$curr_sp]);
 302                         $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP'.$curr_sp.'%%%', $sp_match[1][$curr_sp], $text_blocks[$curr_tb]);
 303                     }
 304                 }
 305             }
 306         }
 307
 308         /* Compile the template tags into PHP code. */
 309         $compiled_tags = array();
 310         for ($i = 0, $for_max = count($template_tags); $i < $for_max; $i++) {
 311             $this->_current_line_no += substr_count($text_blocks[$i], "\n");
 312             $compiled_tags[] = $this->_compile_tag($template_tags[$i]);
 313             $this->_current_line_no += substr_count($template_tags[$i], "\n");
 314         }
 315         if (count($this->_tag_stack)>0) {
 316             list($_open_tag, $_line_no) = end($this->_tag_stack);
 317             $this->_syntax_error("unclosed tag \{$_open_tag} (opened line $_line_no).", E_USER_ERROR, __FILE__, __LINE__);
 318             return;
 319         }
 320
 321         /* Reformat $text_blocks between 'strip' and '/strip' tags,
 322            removing spaces, tabs and newlines. */
 323         $strip = false;
 324         for ($i = 0, $for_max = count($compiled_tags); $i < $for_max; $i++) {
 325             if ($compiled_tags[$i] == '{strip}') {
 326                 $compiled_tags[$i] = '';
 327                 $strip = true;
 328                 /* remove leading whitespaces */
 329                 $text_blocks[$i + 1] = ltrim($text_blocks[$i + 1]);
 330             }
 331             if ($strip) {
 332                 /* strip all $text_blocks before the next '/strip' */
 333                 for ($j = $i + 1; $j < $for_max; $j++) {
 334                     /* remove leading and trailing whitespaces of each line */
 335                     $text_blocks[$j] = preg_replace('![\t ]*[\r\n]+[\t ]*!', '', $text_blocks[$j]);
 336                     if ($compiled_tags[$j] == '{/strip}') {
 337                         /* remove trailing whitespaces from the last text_block */
 338                         $text_blocks[$j] = rtrim($text_blocks[$j]);
 339                     }
 340                     $text_blocks[$j] = "<?php echo '" . strtr($text_blocks[$j], array("'"=>"\'", "\\"=>"\\\\")) . "'; ?>";
 341                     if ($compiled_tags[$j] == '{/strip}') {
 342                         $compiled_tags[$j] = "\n"; /* slurped by php, but necessary
 343                                     if a newline is following the closing strip-tag */
 344                         $strip = false;
 345                         $i = $j;
 346                         break;
 347                     }
 348                 }
 349             }
 350         }
 351         $compiled_content = '';
 352
 353         $tag_guard = '%%%SMARTYOTG' . md5(uniqid(rand(), true)) . '%%%';
 354
 355         /* Interleave the compiled contents and text blocks to get the final result. */
 356         for ($i = 0, $for_max = count($compiled_tags); $i < $for_max; $i++) {
 357             if ($compiled_tags[$i] == '') {
 358                 // tag result empty, remove first newline from following text block
 359                 $text_blocks[$i+1] = preg_replace('~^(\r\n|\r|\n)~', '', $text_blocks[$i+1]);
 360             }
 361             // replace legit PHP tags with placeholder
 362             $text_blocks[$i] = str_replace('<?', $tag_guard, $text_blocks[$i]);
 363             $compiled_tags[$i] = str_replace('<?', $tag_guard, $compiled_tags[$i]);
 364
 365             $compiled_content .= $text_blocks[$i] . $compiled_tags[$i];
 366         }
 367         $compiled_content .= str_replace('<?', $tag_guard, $text_blocks[$i]);
 368
 369         // escape php tags created by interleaving
 370         $compiled_content = str_replace('<?', "<?php echo '<?' ?>\n", $compiled_content);
 371         $compiled_content = preg_replace("~(?<!')language\s*=\s*[\"\']?\s*php\s*[\"\']?~", "<?php echo 'language=php' ?>\n", $compiled_content);
 372
 373         // recover legit tags
 374         $compiled_content = str_replace($tag_guard, '<?', $compiled_content);
 375
 376         // remove \n from the end of the file, if any
 377         if (strlen($compiled_content) && (substr($compiled_content, -1) == "\n") ) {
 378             $compiled_content = substr($compiled_content, 0, -1);
 379         }
 380
 381         if (!empty($this->_cache_serial)) {
 382             $compiled_content = "<?php \$this->_cache_serials['".$this->_cache_include."'] = '".$this->_cache_serial."'; ?>" . $compiled_content;
 383         }
 384
 385         // run compiled template through postfilter functions
 386         if (count($this->_plugins['postfilter']) > 0) {
 387             foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
 388                 if ($postfilter === false) continue;
 389                 if ($postfilter[3] || is_callable($postfilter[0])) {
 390                     $compiled_content = call_user_func_array($postfilter[0],
 391                                                               array($compiled_content, &$this));
 392                     $this->_plugins['postfilter'][$filter_name][3] = true;
 393                 } else {
 394                     $this->_trigger_fatal_error("Smarty plugin error: postfilter '$filter_name' is not implemented");
 395                 }
 396             }
 397         }
 398
 399         // put header at the top of the compiled template
 400         $template_header = "<?php /* Smarty version ".$this->_version.", created on ".strftime("%Y-%m-%d %H:%M:%S")."\n";
 401         $template_header .= "         compiled from ".strtr(urlencode($resource_name), array('%2F'=>'/', '%3A'=>':'))." */ ?>\n";
 402
 403         /* Emit code to load needed plugins. */
 404         $this->_plugins_code = '';
 405         if (count($this->_plugin_info)) {
 406             $_plugins_params = "array('plugins' => array(";
 407             foreach ($this->_plugin_info as $plugin_type => $plugins) {
 408                 foreach ($plugins as $plugin_name => $plugin_info) {
 409                     $_plugins_params .= "array('$plugin_type', '$plugin_name', '" . strtr($plugin_info[0], array("'" => "\\'", "\\" => "\\\\")) . "', $plugin_info[1], ";
 410                     $_plugins_params .= $plugin_info[2] ? 'true),' : 'false),';
 411                 }
 412             }
 413             $_plugins_params .= '))';
 414             $plugins_code = "<?php require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');\nsmarty_core_load_plugins($_plugins_params, \$this); ?>\n";
 415             $template_header .= $plugins_code;
 416             $this->_plugin_info = array();
 417             $this->_plugins_code = $plugins_code;
 418         }
 419
 420         if ($this->_init_smarty_vars) {
 421             $template_header .= "<?php require_once(SMARTY_CORE_DIR . 'core.assign_smarty_interface.php');\nsmarty_core_assign_smarty_interface(null, \$this); ?>\n";
 422             $this->_init_smarty_vars = false;
 423         }
 424
 425         $compiled_content = $template_header . $compiled_content;
 426         return true;
 427     }
 428
 429     /**
 430      * Compile a template tag
 431      *
 432      * @param string $template_tag
 433      * @return string
 434      */
 435     function _compile_tag($template_tag)
 436     {
 437         /* Matched comment. */
 438         if (substr($template_tag, 0, 1) == '*' && substr($template_tag, -1) == '*')
 439             return '';
 440
 441         /* Split tag into two three parts: command, command modifiers and the arguments. */
 442         if(! preg_match('~^(?:(' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp
 443                 . '|\/?' . $this->_reg_obj_regexp . '|\/?' . $this->_func_regexp . ')(' . $this->_mod_regexp . '*))
 444                       (?:\s+(.*))?$
 445                     ~xs', $template_tag, $match)) {
 446             $this->_syntax_error("unrecognized tag: $template_tag", E_USER_ERROR, __FILE__, __LINE__);
 447         }
 448
 449         $tag_command = $match[1];
 450         $tag_modifier = isset($match[2]) ? $match[2] : null;
 451         $tag_args = isset($match[3]) ? $match[3] : null;
 452
 453         if (preg_match('~^' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '$~', $tag_command)) {
 454             /* tag name is a variable or object */
 455             $_return = $this->_parse_var_props($tag_command . $tag_modifier);
 456             return "<?php echo $_return; ?>" . $this->_additional_newline;
 457         }
 458
 459         /* If the tag name is a registered object, we process it. */
 460         if (preg_match('~^\/?' . $this->_reg_obj_regexp . '$~', $tag_command)) {
 461             return $this->_compile_registered_object_tag($tag_command, $this->_parse_attrs($tag_args), $tag_modifier);
 462         }
 463
 464         switch ($tag_command) {
 465             case 'include':
 466                 return $this->_compile_include_tag($tag_args);
 467
 468             case 'include_php':
 469                 return $this->_compile_include_php_tag($tag_args);
 470
 471             case 'if':
 472                 $this->_push_tag('if');
 473                 return $this->_compile_if_tag($tag_args);
 474
 475             case 'else':
 476                 list($_open_tag) = end($this->_tag_stack);
 477                 if ($_open_tag != 'if' && $_open_tag != 'elseif')
 478                     $this->_syntax_error('unexpected {else}', E_USER_ERROR, __FILE__, __LINE__);
 479                 else
 480                     $this->_push_tag('else');
 481                 return '<?php else: ?>';
 482
 483             case 'elseif':
 484                 list($_open_tag) = end($this->_tag_stack);
 485                 if ($_open_tag != 'if' && $_open_tag != 'elseif')
 486                     $this->_syntax_error('unexpected {elseif}', E_USER_ERROR, __FILE__, __LINE__);
 487                 if ($_open_tag == 'if')
 488                     $this->_push_tag('elseif');
 489                 return $this->_compile_if_tag($tag_args, true);
 490
 491             case '/if':
 492                 $this->_pop_tag('if');
 493                 return '<?php endif; ?>';
 494
 495             case 'capture':
 496                 return $this->_compile_capture_tag(true, $tag_args);
 497
 498             case '/capture':
 499                 return $this->_compile_capture_tag(false);
 500
 501             case 'ldelim':
 502                 return $this->left_delimiter;
 503
 504             case 'rdelim':
 505                 return $this->right_delimiter;
 506
 507             case 'section':
 508                 $this->_push_tag('section');
 509                 return $this->_compile_section_start($tag_args);
 510
 511             case 'sectionelse':
 512                 $this->_push_tag('sectionelse');
 513                 return "<?php endfor; else: ?>";
 514                 break;
 515
 516             case '/section':
 517                 $_open_tag = $this->_pop_tag('section');
 518                 if ($_open_tag == 'sectionelse')
 519                     return "<?php endif; ?>";
 520                 else
 521                     return "<?php endfor; endif; ?>";
 522
 523             case 'foreach':
 524                 $this->_push_tag('foreach');
 525                 return $this->_compile_foreach_start($tag_args);
 526                 break;
 527
 528             case 'foreachelse':
 529                 $this->_push_tag('foreachelse');
 530                 return "<?php endforeach; else: ?>";
 531
 532             case '/foreach':
 533                 $_open_tag = $this->_pop_tag('foreach');
 534                 if ($_open_tag == 'foreachelse')
 535                     return "<?php endif; unset(\$_from); ?>";
 536                 else
 537                     return "<?php endforeach; endif; unset(\$_from); ?>";
 538                 break;
 539
 540             case 'strip':
 541             case '/strip':
 542                 if (substr($tag_command, 0, 1)=='/') {
 543                     $this->_pop_tag('strip');
 544                     if (--$this->_strip_depth==0) { /* outermost closing {/strip} */
 545                         $this->_additional_newline = "\n";
 546                         return '{' . $tag_command . '}';
 547                     }
 548                 } else {
 549                     $this->_push_tag('strip');
 550                     if ($this->_strip_depth++==0) { /* outermost opening {strip} */
 551                         $this->_additional_newline = "";
 552                         return '{' . $tag_command . '}';
 553                     }
 554                 }
 555                 return '';
 556
 557             case 'php':
 558                 /* handle folded tags replaced by {php} */
 559                 list(, $block) = each($this->_folded_blocks);
 560                 $this->_current_line_no += substr_count($block[0], "\n");
 561                 /* the number of matched elements in the regexp in _compile_file()
 562                    determins the type of folded tag that was found */
 563                 switch (count($block)) {
 564                     case 2: /* comment */
 565                         return '';
 566
 567                     case 3: /* literal */
 568                         return "<?php echo '" . strtr($block[2], array("'"=>"\'", "\\"=>"\\\\")) . "'; ?>" . $this->_additional_newline;
 569
 570                     case 4: /* php */
 571                         if ($this->security && !$this->security_settings['PHP_TAGS']) {
 572                             $this->_syntax_error("(secure mode) php tags not permitted", E_USER_WARNING, __FILE__, __LINE__);
 573                             return;
 574                         }
 575                         return '<?php ' . $block[3] .' ?>';
 576                 }
 577                 break;
 578
 579             case 'insert':
 580                 return $this->_compile_insert_tag($tag_args);
 581
 582             default:
 583                 if ($this->_compile_compiler_tag($tag_command, $tag_args, $output)) {
 584                     return $output;
 585                 } else if ($this->_compile_block_tag($tag_command, $tag_args, $tag_modifier, $output)) {
 586                     return $output;
 587                 } else if ($this->_compile_custom_tag($tag_command, $tag_args, $tag_modifier, $output)) {
 588                     return $output;
 589                 } else {
 590                     $this->_syntax_error("unrecognized tag '$tag_command'", E_USER_ERROR, __FILE__, __LINE__);
 591                 }
 592
 593         }
 594     }
 595
 596
 597     /**
 598      * compile the custom compiler tag
 599      *
 600      * sets $output to the compiled custom compiler tag
 601      * @param string $tag_command
 602      * @param string $tag_args
 603      * @param string $output
 604      * @return boolean
 605      */
 606     function _compile_compiler_tag($tag_command, $tag_args, &$output)
 607     {
 608         $found = false;
 609         $have_function = true;
 610
 611         /*
 612          * First we check if the compiler function has already been registered
 613          * or loaded from a plugin file.
 614          */
 615         if (isset($this->_plugins['compiler'][$tag_command])) {
 616             $found = true;
 617             $plugin_func = $this->_plugins['compiler'][$tag_command][0];
 618             if (!is_callable($plugin_func)) {
 619                 $message = "compiler function '$tag_command' is not implemented";
 620                 $have_function = false;
 621             }
 622         }
 623         /*
 624          * Otherwise we need to load plugin file and look for the function
 625          * inside it.
 626          */
 627         else if ($plugin_file = $this->_get_plugin_filepath('compiler', $tag_command)) {
 628             $found = true;
 629
 630             include_once $plugin_file;
 631
 632             $plugin_func = 'smarty_compiler_' . $tag_command;
 633             if (!is_callable($plugin_func)) {
 634                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
 635                 $have_function = false;
 636             } else {
 637                 $this->_plugins['compiler'][$tag_command] = array($plugin_func, null, null, null, true);
 638             }
 639         }
 640
 641         /*
 642          * True return value means that we either found a plugin or a
 643          * dynamically registered function. False means that we didn't and the
 644          * compiler should now emit code to load custom function plugin for this
 645          * tag.
 646          */
 647         if ($found) {
 648             if ($have_function) {
 649                 $output = call_user_func_array($plugin_func, array($tag_args, &$this));
 650                 if($output != '') {
 651                 $output = '<?php ' . $this->_push_cacheable_state('compiler', $tag_command)
 652                                    . $output
 653                                    . $this->_pop_cacheable_state('compiler', $tag_command) . ' ?>';
 654                 }
 655             } else {
 656                 $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
 657             }
 658             return true;
 659         } else {
 660             return false;
 661         }
 662     }
 663
 664
 665     /**
 666      * compile block function tag
 667      *
 668      * sets $output to compiled block function tag
 669      * @param string $tag_command
 670      * @param string $tag_args
 671      * @param string $tag_modifier
 672      * @param string $output
 673      * @return boolean
 674      */
 675     function _compile_block_tag($tag_command, $tag_args, $tag_modifier, &$output)
 676     {
 677         if (substr($tag_command, 0, 1) == '/') {
 678             $start_tag = false;
 679             $tag_command = substr($tag_command, 1);
 680         } else
 681             $start_tag = true;
 682
 683         $found = false;
 684         $have_function = true;
 685
 686         /*
 687          * First we check if the block function has already been registered
 688          * or loaded from a plugin file.
 689          */
 690         if (isset($this->_plugins['block'][$tag_command])) {
 691             $found = true;
 692             $plugin_func = $this->_plugins['block'][$tag_command][0];
 693             if (!is_callable($plugin_func)) {
 694                 $message = "block function '$tag_command' is not implemented";
 695                 $have_function = false;
 696             }
 697         }
 698         /*
 699          * Otherwise we need to load plugin file and look for the function
 700          * inside it.
 701          */
 702         else if ($plugin_file = $this->_get_plugin_filepath('block', $tag_command)) {
 703             $found = true;
 704
 705             include_once $plugin_file;
 706
 707             $plugin_func = 'smarty_block_' . $tag_command;
 708             if (!function_exists($plugin_func)) {
 709                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
 710                 $have_function = false;
 711             } else {
 712                 $this->_plugins['block'][$tag_command] = array($plugin_func, null, null, null, true);
 713
 714             }
 715         }
 716
 717         if (!$found) {
 718             return false;
 719         } else if (!$have_function) {
 720             $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
 721             return true;
 722         }
 723
 724         /*
 725          * Even though we've located the plugin function, compilation
 726          * happens only once, so the plugin will still need to be loaded
 727          * at runtime for future requests.
 728          */
 729         $this->_add_plugin('block', $tag_command);
 730
 731         if ($start_tag)
 732             $this->_push_tag($tag_command);
 733         else
 734             $this->_pop_tag($tag_command);
 735
 736         if ($start_tag) {
 737             $output = '<?php ' . $this->_push_cacheable_state('block', $tag_command);
 738             $attrs = $this->_parse_attrs($tag_args);
 739             $_cache_attrs='';
 740             $arg_list = $this->_compile_arg_list('block', $tag_command, $attrs, $_cache_attrs);
 741             $output .= "$_cache_attrs\$this->_tag_stack[] = array('$tag_command', array(".implode(',', $arg_list).')); ';
 742             $output .= '$_block_repeat=true;' . $this->_compile_plugin_call('block', $tag_command).'($this->_tag_stack[count($this->_tag_stack)-1][1], null, $this, $_block_repeat);';
 743             $output .= 'while ($_block_repeat) { ob_start(); ?>';
 744         } else {
 745             $output = '<?php $_block_content = ob_get_contents(); ob_end_clean(); ';
 746             $_out_tag_text = $this->_compile_plugin_call('block', $tag_command).'($this->_tag_stack[count($this->_tag_stack)-1][1], $_block_content, $this, $_block_repeat)';
 747             if ($tag_modifier != '') {
 748                 $this->_parse_modifiers($_out_tag_text, $tag_modifier);
 749             }
 750             $output .= '$_block_repeat=false;echo ' . $_out_tag_text . '; } ';
 751             $output .= " array_pop(\$this->_tag_stack); " . $this->_pop_cacheable_state('block', $tag_command) . '?>';
 752         }
 753
 754         return true;
 755     }
 756
 757
 758     /**
 759      * compile custom function tag
 760      *
 761      * @param string $tag_command
 762      * @param string $tag_args
 763      * @param string $tag_modifier
 764      * @return string
 765      */
 766     function _compile_custom_tag($tag_command, $tag_args, $tag_modifier, &$output)
 767     {
 768         $found = false;
 769         $have_function = true;
 770
 771         /*
 772          * First we check if the custom function has already been registered
 773          * or loaded from a plugin file.
 774          */
 775         if (isset($this->_plugins['function'][$tag_command])) {
 776             $found = true;
 777             $plugin_func = $this->_plugins['function'][$tag_command][0];
 778             if (!is_callable($plugin_func)) {
 779                 $message = "custom function '$tag_command' is not implemented";
 780                 $have_function = false;
 781             }
 782         }
 783         /*
 784          * Otherwise we need to load plugin file and look for the function
 785          * inside it.
 786          */
 787         else if ($plugin_file = $this->_get_plugin_filepath('function', $tag_command)) {
 788             $found = true;
 789
 790             include_once $plugin_file;
 791
 792             $plugin_func = 'smarty_function_' . $tag_command;
 793             if (!function_exists($plugin_func)) {
 794                 $message = "plugin function $plugin_func() not found in $plugin_file\n";
 795                 $have_function = false;
 796             } else {
 797                 $this->_plugins['function'][$tag_command] = array($plugin_func, null, null, null, true);
 798
 799             }
 800         }
 801
 802         if (!$found) {
 803             return false;
 804         } else if (!$have_function) {
 805             $this->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
 806             return true;
 807         }
 808
 809         /* declare plugin to be loaded on display of the template that
 810            we compile right now */
 811         $this->_add_plugin('function', $tag_command);
 812
 813         $_cacheable_state = $this->_push_cacheable_state('function', $tag_command);
 814         $attrs = $this->_parse_attrs($tag_args);
 815         $_cache_attrs = '';
 816         $arg_list = $this->_compile_arg_list('function', $tag_command, $attrs, $_cache_attrs);
 817
 818         $output = $this->_compile_plugin_call('function', $tag_command).'(array('.implode(',', $arg_list)."), \$this)";
 819         if($tag_modifier != '') {
 820             $this->_parse_modifiers($output, $tag_modifier);
 821         }
 822
 823         if($output != '') {
 824             $output =  '<?php ' . $_cacheable_state . $_cache_attrs . 'echo ' . $output . ';'
 825                 . $this->_pop_cacheable_state('function', $tag_command) . "?>" . $this->_additional_newline;
 826         }
 827
 828         return true;
 829     }
 830
 831     /**
 832      * compile a registered object tag
 833      *
 834      * @param string $tag_command
 835      * @param array $attrs
 836      * @param string $tag_modifier
 837      * @return string
 838      */
 839     function _compile_registered_object_tag($tag_command, $attrs, $tag_modifier)
 840     {
 841         if (substr($tag_command, 0, 1) == '/') {
 842             $start_tag = false;
 843             $tag_command = substr($tag_command, 1);
 844         } else {
 845             $start_tag = true;
 846         }
 847
 848         list($object, $obj_comp) = explode('->', $tag_command);
 849
 850         $arg_list = array();
 851         if(count($attrs)) {
 852             $_assign_var = false;
 853             foreach ($attrs as $arg_name => $arg_value) {
 854                 if($arg_name == 'assign') {
 855                     $_assign_var = $arg_value;
 856                     unset($attrs['assign']);
 857                     continue;
 858                 }
 859                 if (is_bool($arg_value))
 860                     $arg_value = $arg_value ? 'true' : 'false';
 861                 $arg_list[] = "'$arg_name' => $arg_value";
 862             }
 863         }
 864
 865         if($this->_reg_objects[$object][2]) {
 866             // smarty object argument format
 867             $args = "array(".implode(',', (array)$arg_list)."), \$this";
 868         } else {
 869             // traditional argument format
 870             $args = implode(',', array_values($attrs));
 871             if (empty($args)) {
 872                 $args = '';
 873             }
 874         }
 875
 876         $prefix = '';
 877         $postfix = '';
 878         $newline = '';
 879         if(!is_object($this->_reg_objects[$object][0])) {
 880             $this->_trigger_fatal_error("registered '$object' is not an object" , $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
 881         } elseif(!empty($this->_reg_objects[$object][1]) && !in_array($obj_comp, $this->_reg_objects[$object][1])) {
 882             $this->_trigger_fatal_error("'$obj_comp' is not a registered component of object '$object'", $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
 883         } elseif(method_exists($this->_reg_objects[$object][0], $obj_comp)) {
 884             // method
 885             if(in_array($obj_comp, $this->_reg_objects[$object][3])) {
 886                 // block method
 887                 if ($start_tag) {
 888                     $prefix = "\$this->_tag_stack[] = array('$obj_comp', $args); ";
 889                     $prefix .= "\$_block_repeat=true; \$this->_reg_objects['$object'][0]->$obj_comp(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], null, \$this, \$_block_repeat); ";
 890                     $prefix .= "while (\$_block_repeat) { ob_start();";
 891                     $return = null;
 892                     $postfix = '';
 893                 } else {
 894                     $prefix = "\$_obj_block_content = ob_get_contents(); ob_end_clean(); \$_block_repeat=false;";
 895                     $return = "\$this->_reg_objects['$object'][0]->$obj_comp(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], \$_obj_block_content, \$this, \$_block_repeat)";
 896                     $postfix = "} array_pop(\$this->_tag_stack);";
 897                 }
 898             } else {
 899                 // non-block method
 900                 $return = "\$this->_reg_objects['$object'][0]->$obj_comp($args)";
 901             }
 902         } else {
 903             // property
 904             $return = "\$this->_reg_objects['$object'][0]->$obj_comp";
 905         }
 906
 907         if($return != null) {
 908             if($tag_modifier != '') {
 909                 $this->_parse_modifiers($return, $tag_modifier);
 910             }
 911
 912             if(!empty($_assign_var)) {
 913                 $output = "\$this->assign('" . $this->_dequote($_assign_var) ."',  $return);";
 914             } else {
 915                 $output = 'echo ' . $return . ';';
 916                 $newline = $this->_additional_newline;
 917             }
 918         } else {
 919             $output = '';
 920         }
 921
 922         return '<?php ' . $prefix . $output . $postfix . "?>" . $newline;
 923     }
 924
 925     /**
 926      * Compile {insert ...} tag
 927      *
 928      * @param string $tag_args
 929      * @return string
 930      */
 931     function _compile_insert_tag($tag_args)
 932     {
 933         $attrs = $this->_parse_attrs($tag_args);
 934         $name = $this->_dequote($attrs['name']);
 935
 936         if (empty($name)) {
 937             return $this->_syntax_error("missing insert name", E_USER_ERROR, __FILE__, __LINE__);
 938         }
 939
 940         if (!preg_match('~^\w+$~', $name)) {
 941             return $this->_syntax_error("'insert: 'name' must be an insert function name", E_USER_ERROR, __FILE__, __LINE__);
 942         }
 943
 944         if (!empty($attrs['script'])) {
 945             $delayed_loading = true;
 946         } else {
 947             $delayed_loading = false;
 948         }
 949
 950         foreach ($attrs as $arg_name => $arg_value) {
 951             if (is_bool($arg_value))
 952                 $arg_value = $arg_value ? 'true' : 'false';
 953             $arg_list[] = "'$arg_name' => $arg_value";
 954         }
 955
 956         $this->_add_plugin('insert', $name, $delayed_loading);
 957
 958         $_params = "array('args' => array(".implode(', ', (array)$arg_list)."))";
 959
 960         return "<?php require_once(SMARTY_CORE_DIR . 'core.run_insert_handler.php');\necho smarty_core_run_insert_handler($_params, \$this); ?>" . $this->_additional_newline;
 961     }
 962
 963     /**
 964      * Compile {include ...} tag
 965      *
 966      * @param string $tag_args
 967      * @return string
 968      */
 969     function _compile_include_tag($tag_args)
 970     {
 971         $attrs = $this->_parse_attrs($tag_args);
 972         $arg_list = array();
 973
 974         if (empty($attrs['file'])) {
 975             $this->_syntax_error("missing 'file' attribute in include tag", E_USER_ERROR, __FILE__, __LINE__);
 976         }
 977
 978         foreach ($attrs as $arg_name => $arg_value) {
 979             if ($arg_name == 'file') {
 980                 $include_file = $arg_value;
 981                 continue;
 982             } else if ($arg_name == 'assign') {
 983                 $assign_var = $arg_value;
 984                 continue;
 985             }
 986             if (is_bool($arg_value))
 987                 $arg_value = $arg_value ? 'true' : 'false';
 988             $arg_list[] = "'$arg_name' => $arg_value";
 989         }
 990
 991         $output = '<?php ';
 992
 993         if (isset($assign_var)) {
 994             $output .= "ob_start();\n";
 995         }
 996
 997         $output .=
 998             "\$_smarty_tpl_vars = \$this->_tpl_vars;\n";
 999
1000
1001         $_params = "array('smarty_include_tpl_file' => " . $include_file . ", 'smarty_include_vars' => array(".implode(',', (array)$arg_list)."))";
1002         $output .= "\$this->_smarty_include($_params);\n" .
1003         "\$this->_tpl_vars = \$_smarty_tpl_vars;\n" .
1004         "unset(\$_smarty_tpl_vars);\n";
1005
1006         if (isset($assign_var)) {
1007             $output .= "\$this->assign(" . $assign_var . ", ob_get_contents()); ob_end_clean();\n";
1008         }
1009
1010         $output .= ' ?>';
1011
1012         return $output;
1013
1014     }
1015
1016     /**
1017      * Compile {include ...} tag
1018      *
1019      * @param string $tag_args
1020      * @return string
1021      */
1022     function _compile_include_php_tag($tag_args)
1023     {
1024         $attrs = $this->_parse_attrs($tag_args);
1025
1026         if (empty($attrs['file'])) {
1027             $this->_syntax_error("missing 'file' attribute in include_php tag", E_USER_ERROR, __FILE__, __LINE__);
1028         }
1029
1030         $assign_var = (empty($attrs['assign'])) ? '' : $this->_dequote($attrs['assign']);
1031         $once_var = (empty($attrs['once']) || $attrs['once']=='false') ? 'false' : 'true';
1032
1033         $arg_list = array();
1034         foreach($attrs as $arg_name => $arg_value) {
1035             if($arg_name != 'file' AND $arg_name != 'once' AND $arg_name != 'assign') {
1036                 if(is_bool($arg_value))
1037                     $arg_value = $arg_value ? 'true' : 'false';
1038                 $arg_list[] = "'$arg_name' => $arg_value";
1039             }
1040         }
1041
1042         $_params = "array('smarty_file' => " . $attrs['file'] . ", 'smarty_assign' => '$assign_var', 'smarty_once' => $once_var, 'smarty_include_vars' => array(".implode(',', $arg_list)."))";
1043
1044         return "<?php require_once(SMARTY_CORE_DIR . 'core.smarty_include_php.php');\nsmarty_core_smarty_include_php($_params, \$this); ?>" . $this->_additional_newline;
1045     }
1046
1047
1048     /**
1049      * Compile {section ...} tag
1050      *
1051      * @param string $tag_args
1052      * @return string
1053      */
1054     function _compile_section_start($tag_args)
1055     {
1056         $attrs = $this->_parse_attrs($tag_args);
1057         $arg_list = array();
1058
1059         $output = '<?php ';
1060         $section_name = $attrs['name'];
1061         if (empty($section_name)) {
1062             $this->_syntax_error("missing section name", E_USER_ERROR, __FILE__, __LINE__);
1063         }
1064
1065         $output .= "unset(\$this->_sections[$section_name]);\n";
1066         $section_props = "\$this->_sections[$section_name]";
1067
1068         foreach ($attrs as $attr_name => $attr_value) {
1069             switch ($attr_name) {
1070                 case 'loop':
1071                     $output .= "{$section_props}['loop'] = is_array(\$_loop=$attr_value) ? count(\$_loop) : max(0, (int)\$_loop); unset(\$_loop);\n";
1072                     break;
1073
1074                 case 'show':
1075                     if (is_bool($attr_value))
1076                         $show_attr_value = $attr_value ? 'true' : 'false';
1077                     else
1078                         $show_attr_value = "(bool)$attr_value";
1079                     $output .= "{$section_props}['show'] = $show_attr_value;\n";
1080                     break;
1081
1082                 case 'name':
1083                     $output .= "{$section_props}['$attr_name'] = $attr_value;\n";
1084                     break;
1085
1086                 case 'max':
1087                 case 'start':
1088                     $output .= "{$section_props}['$attr_name'] = (int)$attr_value;\n";
1089                     break;
1090
1091                 case 'step':
1092                     $output .= "{$section_props}['$attr_name'] = ((int)$attr_value) == 0 ? 1 : (int)$attr_value;\n";
1093                     break;
1094
1095                 default:
1096                     $this->_syntax_error("unknown section attribute - '$attr_name'", E_USER_ERROR, __FILE__, __LINE__);
1097                     break;
1098             }
1099         }
1100
1101         if (!isset($attrs['show']))
1102             $output .= "{$section_props}['show'] = true;\n";
1103
1104         if (!isset($attrs['loop']))
1105             $output .= "{$section_props}['loop'] = 1;\n";
1106
1107         if (!isset($attrs['max']))
1108             $output .= "{$section_props}['max'] = {$section_props}['loop'];\n";
1109         else
1110             $output .= "if ({$section_props}['max'] < 0)\n" .
1111                        "    {$section_props}['max'] = {$section_props}['loop'];\n";
1112
1113         if (!isset($attrs['step']))
1114             $output .= "{$section_props}['step'] = 1;\n";
1115
1116         if (!isset($attrs['start']))
1117             $output .= "{$section_props}['start'] = {$section_props}['step'] > 0 ? 0 : {$section_props}['loop']-1;\n";
1118         else {
1119             $output .= "if ({$section_props}['start'] < 0)\n" .
1120                        "    {$section_props}['start'] = max({$section_props}['step'] > 0 ? 0 : -1, {$section_props}['loop'] + {$section_props}['start']);\n" .
1121                        "else\n" .
1122                        "    {$section_props}['start'] = min({$section_props}['start'], {$section_props}['step'] > 0 ? {$section_props}['loop'] : {$section_props}['loop']-1);\n";
1123         }
1124
1125         $output .= "if ({$section_props}['show']) {\n";
1126         if (!isset($attrs['start']) && !isset($attrs['step']) && !isset($attrs['max'])) {
1127             $output .= "    {$section_props}['total'] = {$section_props}['loop'];\n";
1128         } else {
1129             $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";
1130         }
1131         $output .= "    if ({$section_props}['total'] == 0)\n" .
1132                    "        {$section_props}['show'] = false;\n" .
1133                    "} else\n" .
1134                    "    {$section_props}['total'] = 0;\n";
1135
1136         $output .= "if ({$section_props}['show']):\n";
1137         $output .= "
1138             for ({$section_props}['index'] = {$section_props}['start'], {$section_props}['iteration'] = 1;
1139                  {$section_props}['iteration'] <= {$section_props}['total'];
1140                  {$section_props}['index'] += {$section_props}['step'], {$section_props}['iteration']++):\n";
1141         $output .= "{$section_props}['rownum'] = {$section_props}['iteration'];\n";
1142         $output .= "{$section_props}['index_prev'] = {$section_props}['index'] - {$section_props}['step'];\n";
1143         $output .= "{$section_props}['index_next'] = {$section_props}['index'] + {$section_props}['step'];\n";
1144         $output .= "{$section_props}['first']      = ({$section_props}['iteration'] == 1);\n";
1145         $output .= "{$section_props}['last']       = ({$section_props}['iteration'] == {$section_props}['total']);\n";
1146
1147         $output .= "?>";
1148
1149         return $output;
1150     }
1151
1152
1153     /**
1154      * Compile {foreach ...} tag.
1155      *
1156      * @param string $tag_args
1157      * @return string
1158      */
1159     function _compile_foreach_start($tag_args)
1160     {
1161         $attrs = $this->_parse_attrs($tag_args);
1162         $arg_list = array();
1163
1164         if (empty($attrs['from'])) {
1165             return $this->_syntax_error("foreach: missing 'from' attribute", E_USER_ERROR, __FILE__, __LINE__);
1166         }
1167         $from = $attrs['from'];
1168
1169         if (empty($attrs['item'])) {
1170             return $this->_syntax_error("foreach: missing 'item' attribute", E_USER_ERROR, __FILE__, __LINE__);
1171         }
1172         $item = $this->_dequote($attrs['item']);
1173         if (!preg_match('~^\w+$~', $item)) {
1174             return $this->_syntax_error("foreach: 'item' must be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
1175         }
1176
1177         if (isset($attrs['key'])) {
1178             $key  = $this->_dequote($attrs['key']);
1179             if (!preg_match('~^\w+$~', $key)) {
1180                 return $this->_syntax_error("foreach: 'key' must to be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
1181             }
1182             $key_part = "\$this->_tpl_vars['$key'] => ";
1183         } else {
1184             $key = null;
1185             $key_part = '';
1186         }
1187
1188         if (isset($attrs['name'])) {
1189             $name = $attrs['name'];
1190         } else {
1191             $name = null;
1192         }
1193
1194         $output = '<?php ';
1195         $output .= "\$_from = $from; if (!is_array(\$_from) && !is_object(\$_from)) { settype(\$_from, 'array'); }";
1196         if (isset($name)) {
1197             $foreach_props = "\$this->_foreach[$name]";
1198             $output .= "{$foreach_props} = array('total' => count(\$_from), 'iteration' => 0);\n";
1199             $output .= "if ({$foreach_props}['total'] > 0):\n";
1200             $output .= "    foreach (\$_from as $key_part\$this->_tpl_vars['$item']):\n";
1201             $output .= "        {$foreach_props}['iteration']++;\n";
1202         } else {
1203             $output .= "if (count(\$_from)):\n";
1204             $output .= "    foreach (\$_from as $key_part\$this->_tpl_vars['$item']):\n";
1205         }
1206         $output .= '?>';
1207
1208         return $output;
1209     }
1210
1211
1212     /**
1213      * Compile {capture} .. {/capture} tags
1214      *
1215      * @param boolean $start true if this is the {capture} tag
1216      * @param string $tag_args
1217      * @return string
1218      */
1219
1220     function _compile_capture_tag($start, $tag_args = '')
1221     {
1222         $attrs = $this->_parse_attrs($tag_args);
1223
1224         if ($start) {
1225             $buffer = isset($attrs['name']) ? $attrs['name'] : "'default'";
1226             $assign = isset($attrs['assign']) ? $attrs['assign'] : null;
1227             $append = isset($attrs['append']) ? $attrs['append'] : null;
1228
1229             $output = "<?php ob_start(); ?>";
1230             $this->_capture_stack[] = array($buffer, $assign, $append);
1231         } else {
1232             list($buffer, $assign, $append) = array_pop($this->_capture_stack);
1233             $output = "<?php \$this->_smarty_vars['capture'][$buffer] = ob_get_contents(); ";
1234             if (isset($assign)) {
1235                 $output .= " \$this->assign($assign, ob_get_contents());";
1236             }
1237             if (isset($append)) {
1238                 $output .= " \$this->append($append, ob_get_contents());";
1239             }
1240             $output .= "ob_end_clean(); ?>";
1241         }
1242
1243         return $output;
1244     }
1245
1246     /**
1247      * Compile {if ...} tag
1248      *
1249      * @param string $tag_args
1250      * @param boolean $elseif if true, uses elseif instead of if
1251      * @return string
1252      */
1253     function _compile_if_tag($tag_args, $elseif = false)
1254     {
1255
1256         /* Tokenize args for 'if' tag. */
1257         preg_match_all('~(?>
1258                 ' . $this->_obj_call_regexp . '(?:' . $this->_mod_regexp . '*)? | # valid object call
1259                 ' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)?    | # var or quoted string
1260                 \-?0[xX][0-9a-fA-F]+|\-?\d+(?:\.\d+)?|\.\d+|!==|===|==|!=|<>|<<|>>|<=|>=|\&\&|\|\||\(|\)|,|\!|\^|=|\&|\~|<|>|\||\%|\+|\-|\/|\*|\@    | # valid non-word token
1261                 \b\w+\b                                                        | # valid word token
1262                 \S+                                                           # anything else
1263                 )~x', $tag_args, $match);
1264
1265         $tokens = $match[0];
1266
1267         if(empty($tokens)) {
1268             $_error_msg = $elseif ? "'elseif'" : "'if'";
1269             $_error_msg .= ' statement requires arguments';
1270             $this->_syntax_error($_error_msg, E_USER_ERROR, __FILE__, __LINE__);
1271         }
1272
1273
1274         // make sure we have balanced parenthesis
1275         $token_count = array_count_values($tokens);
1276         if(isset($token_count['(']) && $token_count['('] != $token_count[')']) {
1277             $this->_syntax_error("unbalanced parenthesis in if statement", E_USER_ERROR, __FILE__, __LINE__);
1278         }
1279
1280         $is_arg_stack = array();
1281
1282         for ($i = 0; $i < count($tokens); $i++) {
1283
1284             $token = &$tokens[$i];
1285
1286             switch (strtolower($token)) {
1287                 case '!':
1288                 case '%':
1289                 case '!==':
1290                 case '==':
1291                 case '===':
1292                 case '>':
1293                 case '<':
1294                 case '!=':
1295                 case '<>':
1296                 case '<<':
1297                 case '>>':
1298                 case '<=':
1299                 case '>=':
1300                 case '&&':
1301                 case '||':
1302                 case '|':
1303                 case '^':
1304                 case '&':
1305                 case '~':
1306                 case ')':
1307                 case ',':
1308                 case '+':
1309                 case '-':
1310                 case '*':
1311                 case '/':
1312                 case '@':
1313                     break;
1314
1315                 case 'eq':
1316                     $token = '==';
1317                     break;
1318
1319                 case 'ne':
1320                 case 'neq':
1321                     $token = '!=';
1322                     break;
1323
1324                 case 'lt':
1325                     $token = '<';
1326                     break;
1327
1328                 case 'le':
1329                 case 'lte':
1330                     $token = '<=';
1331                     break;
1332
1333                 case 'gt':
1334                     $token = '>';
1335                     break;
1336
1337                 case 'ge':
1338                 case 'gte':
1339                     $token = '>=';
1340                     break;
1341
1342                 case 'and':
1343                     $token = '&&';
1344                     break;
1345
1346                 case 'or':
1347                     $token = '||';
1348                     break;
1349
1350                 case 'not':
1351                     $token = '!';
1352                     break;
1353
1354                 case 'mod':
1355                     $token = '%';
1356                     break;
1357
1358                 case '(':
1359                     array_push($is_arg_stack, $i);
1360                     break;
1361
1362                 case 'is':
1363                     /* If last token was a ')', we operate on the parenthesized
1364                        expression. The start of the expression is on the stack.
1365                        Otherwise, we operate on the last encountered token. */
1366                     if ($tokens[$i-1] == ')')
1367                         $is_arg_start = array_pop($is_arg_stack);
1368                     else
1369                         $is_arg_start = $i-1;
1370                     /* Construct the argument for 'is' expression, so it knows
1371                        what to operate on. */
1372                     $is_arg = implode(' ', array_slice($tokens, $is_arg_start, $i - $is_arg_start));
1373
1374                     /* Pass all tokens from next one until the end to the
1375                        'is' expression parsing function. The function will
1376                        return modified tokens, where the first one is the result
1377                        of the 'is' expression and the rest are the tokens it
1378                        didn't touch. */
1379                     $new_tokens = $this->_parse_is_expr($is_arg, array_slice($tokens, $i+1));
1380
1381                     /* Replace the old tokens with the new ones. */
1382                     array_splice($tokens, $is_arg_start, count($tokens), $new_tokens);
1383
1384                     /* Adjust argument start so that it won't change from the
1385                        current position for the next iteration. */
1386                     $i = $is_arg_start;
1387                     break;
1388
1389                 default:
1390                     if(preg_match('~^' . $this->_func_regexp . '$~', $token) ) {
1391                             // function call
1392                             if($this->security &&
1393                                !in_array($token, $this->security_settings['IF_FUNCS'])) {
1394                                 $this->_syntax_error("(secure mode) '$token' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
1395                             }
1396                     } elseif(preg_match('~^' . $this->_var_regexp . '$~', $token) && (strpos('+-*/^%&|', substr($token, -1)) === false) && isset($tokens[$i+1]) && $tokens[$i+1] == '(') {
1397                         // variable function call
1398                         $this->_syntax_error("variable function call '$token' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
1399                     } elseif(preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)$~', $token)) {
1400                         // object or variable
1401                         $token = $this->_parse_var_props($token);
1402                     } elseif(is_numeric($token)) {
1403                         // number, skip it
1404                     } else {
1405                         $this->_syntax_error("unidentified token '$token'", E_USER_ERROR, __FILE__, __LINE__);
1406                     }
1407                     break;
1408             }
1409         }
1410
1411         if ($elseif)
1412             return '<?php elseif ('.implode(' ', $tokens).'): ?>';
1413         else
1414             return '<?php if ('.implode(' ', $tokens).'): ?>';
1415     }
1416
1417
1418     function _compile_arg_list($type, $name, $attrs, &$cache_code) {
1419         $arg_list = array();
1420
1421         if (isset($type) && isset($name)
1422             && isset($this->_plugins[$type])
1423             && isset($this->_plugins[$type][$name])
1424             && empty($this->_plugins[$type][$name][4])
1425             && is_array($this->_plugins[$type][$name][5])
1426             ) {
1427             /* we have a list of parameters that should be cached */
1428             $_cache_attrs = $this->_plugins[$type][$name][5];
1429             $_count = $this->_cache_attrs_count++;
1430             $cache_code = "\$_cache_attrs =& \$this->_smarty_cache_attrs('$this->_cache_serial','$_count');";
1431
1432         } else {
1433             /* no parameters are cached */
1434             $_cache_attrs = null;
1435         }
1436
1437         foreach ($attrs as $arg_name => $arg_value) {
1438             if (is_bool($arg_value))
1439                 $arg_value = $arg_value ? 'true' : 'false';
1440             if (is_null($arg_value))
1441                 $arg_value = 'null';
1442             if ($_cache_attrs && in_array($arg_name, $_cache_attrs)) {
1443                 $arg_list[] = "'$arg_name' => (\$this->_cache_including) ? \$_cache_attrs['$arg_name'] : (\$_cache_attrs['$arg_name']=$arg_value)";
1444             } else {
1445                 $arg_list[] = "'$arg_name' => $arg_value";
1446             }
1447         }
1448         return $arg_list;
1449     }
1450
1451     /**
1452      * Parse is expression
1453      *
1454      * @param string $is_arg
1455      * @param array $tokens
1456      * @return array
1457      */
1458     function _parse_is_expr($is_arg, $tokens)
1459     {
1460         $expr_end = 0;
1461         $negate_expr = false;
1462
1463         if (($first_token = array_shift($tokens)) == 'not') {
1464             $negate_expr = true;
1465             $expr_type = array_shift($tokens);
1466         } else
1467             $expr_type = $first_token;
1468
1469         switch ($expr_type) {
1470             case 'even':
1471                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
1472                     $expr_end++;
1473                     $expr_arg = $tokens[$expr_end++];
1474                     $expr = "!(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
1475                 } else
1476                     $expr = "!(1 & $is_arg)";
1477                 break;
1478
1479             case 'odd':
1480                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
1481                     $expr_end++;
1482                     $expr_arg = $tokens[$expr_end++];
1483                     $expr = "(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
1484                 } else
1485                     $expr = "(1 & $is_arg)";
1486                 break;
1487
1488             case 'div':
1489                 if (@$tokens[$expr_end] == 'by') {
1490                     $expr_end++;
1491                     $expr_arg = $tokens[$expr_end++];
1492                     $expr = "!($is_arg % " . $this->_parse_var_props($expr_arg) . ")";
1493                 } else {
1494                     $this->_syntax_error("expecting 'by' after 'div'", E_USER_ERROR, __FILE__, __LINE__);
1495                 }
1496                 break;
1497
1498             default:
1499                 $this->_syntax_error("unknown 'is' expression - '$expr_type'", E_USER_ERROR, __FILE__, __LINE__);
1500                 break;
1501         }
1502
1503         if ($negate_expr) {
1504             $expr = "!($expr)";
1505         }
1506
1507         array_splice($tokens, 0, $expr_end, $expr);
1508
1509         return $tokens;
1510     }
1511
1512
1513     /**
1514      * Parse attribute string
1515      *
1516      * @param string $tag_args
1517      * @return array
1518      */
1519     function _parse_attrs($tag_args)
1520     {
1521
1522         /* Tokenize tag attributes. */
1523         preg_match_all('~(?:' . $this->_obj_call_regexp . '|' . $this->_qstr_regexp . ' | (?>[^"\'=\s]+)
1524                          )+ |
1525                          [=]
1526                         ~x', $tag_args, $match);
1527         $tokens       = $match[0];
1528
1529         $attrs = array();
1530         /* Parse state:
1531             0 - expecting attribute name
1532             1 - expecting '='
1533             2 - expecting attribute value (not '=') */
1534         $state = 0;
1535
1536         foreach ($tokens as $token) {
1537             switch ($state) {
1538                 case 0:
1539                     /* If the token is a valid identifier, we set attribute name
1540                        and go to state 1. */
1541                     if (preg_match('~^\w+$~', $token)) {
1542                         $attr_name = $token;
1543                         $state = 1;
1544                     } else
1545                         $this->_syntax_error("invalid attribute name: '$token'", E_USER_ERROR, __FILE__, __LINE__);
1546                     break;
1547
1548                 case 1:
1549                     /* If the token is '=', then we go to state 2. */
1550                     if ($token == '=') {
1551                         $state = 2;
1552                     } else
1553                         $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
1554                     break;
1555
1556                 case 2:
1557                     /* If token is not '=', we set the attribute value and go to
1558                        state 0. */
1559                     if ($token != '=') {
1560                         /* We booleanize the token if it's a non-quoted possible
1561                            boolean value. */
1562                         if (preg_match('~^(on|yes|true)$~', $token)) {
1563                             $token = 'true';
1564                         } else if (preg_match('~^(off|no|false)$~', $token)) {
1565                             $token = 'false';
1566                         } else if ($token == 'null') {
1567                             $token = 'null';
1568                         } else if (preg_match('~^' . $this->_num_const_regexp . '|0[xX][0-9a-fA-F]+$~', $token)) {
1569                             /* treat integer literally */
1570                         } else if (!preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . ')*$~', $token)) {
1571                             /* treat as a string, double-quote it escaping quotes */
1572                             $token = '"'.addslashes($token).'"';
1573                         }
1574
1575                         $attrs[$attr_name] = $token;
1576                         $state = 0;
1577                     } else
1578                         $this->_syntax_error("'=' cannot be an attribute value", E_USER_ERROR, __FILE__, __LINE__);
1579                     break;
1580             }
1581             $last_token = $token;
1582         }
1583
1584         if($state != 0) {
1585             if($state == 1) {
1586                 $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
1587             } else {
1588                 $this->_syntax_error("missing attribute value", E_USER_ERROR, __FILE__, __LINE__);
1589             }
1590         }
1591
1592         $this->_parse_vars_props($attrs);
1593
1594         return $attrs;
1595     }
1596
1597     /**
1598      * compile multiple variables and section properties tokens into
1599      * PHP code
1600      *
1601      * @param array $tokens
1602      */
1603     function _parse_vars_props(&$tokens)
1604     {
1605         foreach($tokens as $key => $val) {
1606             $tokens[$key] = $this->_parse_var_props($val);
1607         }
1608     }
1609
1610     /**
1611      * compile single variable and section properties token into
1612      * PHP code
1613      *
1614      * @param string $val
1615      * @param string $tag_attrs
1616      * @return string
1617      */
1618     function _parse_var_props($val)
1619     {
1620         $val = trim($val);
1621
1622         if(preg_match('~^(' . $this->_obj_call_regexp . '|' . $this->_dvar_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match)) {
1623             // $ variable or object
1624             $return = $this->_parse_var($match[1]);
1625             $modifiers = $match[2];
1626             if (!empty($this->default_modifiers) && !preg_match('~(^|\|)smarty:nodefaults($|\|)~',$modifiers)) {
1627                 $_default_mod_string = implode('|',(array)$this->default_modifiers);
1628                 $modifiers = empty($modifiers) ? $_default_mod_string : $_default_mod_string . '|' . $modifiers;
1629             }
1630             $this->_parse_modifiers($return, $modifiers);
1631             return $return;
1632         } elseif (preg_match('~^' . $this->_db_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1633                 // double quoted text
1634                 preg_match('~^(' . $this->_db_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1635                 $return = $this->_expand_quoted_text($match[1]);
1636                 if($match[2] != '') {
1637                     $this->_parse_modifiers($return, $match[2]);
1638                 }
1639                 return $return;
1640             }
1641         elseif(preg_match('~^' . $this->_num_const_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1642                 // numerical constant
1643                 preg_match('~^(' . $this->_num_const_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1644                 if($match[2] != '') {
1645                     $this->_parse_modifiers($match[1], $match[2]);
1646                     return $match[1];
1647                 }
1648             }
1649         elseif(preg_match('~^' . $this->_si_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1650                 // single quoted text
1651                 preg_match('~^(' . $this->_si_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1652                 if($match[2] != '') {
1653                     $this->_parse_modifiers($match[1], $match[2]);
1654                     return $match[1];
1655                 }
1656             }
1657         elseif(preg_match('~^' . $this->_cvar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1658                 // config var
1659                 return $this->_parse_conf_var($val);
1660             }
1661         elseif(preg_match('~^' . $this->_svar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1662                 // section var
1663                 return $this->_parse_section_prop($val);
1664             }
1665         elseif(!in_array($val, $this->_permitted_tokens) && !is_numeric($val)) {
1666             // literal string
1667             return $this->_expand_quoted_text('"' . strtr($val, array('\\' => '\\\\', '"' => '\\"')) .'"');
1668         }
1669         return $val;
1670     }
1671
1672     /**
1673      * expand quoted text with embedded variables
1674      *
1675      * @param string $var_expr
1676      * @return string
1677      */
1678     function _expand_quoted_text($var_expr)
1679     {
1680         // if contains unescaped $, expand it
1681         if(preg_match_all('~(?:\`(?<!\\\\)\$' . $this->_dvar_guts_regexp . '(?:' . $this->_obj_ext_regexp . ')*\`)|(?:(?<!\\\\)\$\w+(\[[a-zA-Z0-9]+\])*)~', $var_expr, $_match)) {
1682             $_match = $_match[0];
1683             $_replace = array();
1684             foreach($_match as $_var) {
1685                 $_replace[$_var] = '".(' . $this->_parse_var(str_replace('`','',$_var)) . ')."';
1686             }
1687             $var_expr = strtr($var_expr, $_replace);
1688             $_return = preg_replace('~\.""|(?<!\\\\)""\.~', '', $var_expr);
1689         } else {
1690             $_return = $var_expr;
1691         }
1692         // replace double quoted literal string with single quotes
1693         $_return = preg_replace('~^"([\s\w]+)"$~',"'\\1'",$_return);
1694         return $_return;
1695     }
1696
1697     /**
1698      * parse variable expression into PHP code
1699      *
1700      * @param string $var_expr
1701      * @param string $output
1702      * @return string
1703      */
1704     function _parse_var($var_expr)
1705     {
1706         $_has_math = false;
1707         $_math_vars = preg_split('~('.$this->_dvar_math_regexp.'|'.$this->_qstr_regexp.')~', $var_expr, -1, PREG_SPLIT_DELIM_CAPTURE);
1708
1709         if(count($_math_vars) > 1) {
1710             $_first_var = "";
1711             $_complete_var = "";
1712             $_output = "";
1713             // simple check if there is any math, to stop recursion (due to modifiers with "xx % yy" as parameter)
1714             foreach($_math_vars as $_k => $_math_var) {
1715                 $_math_var = $_math_vars[$_k];
1716
1717                 if(!empty($_math_var) || is_numeric($_math_var)) {
1718                     // hit a math operator, so process the stuff which came before it
1719                     if(preg_match('~^' . $this->_dvar_math_regexp . '$~', $_math_var)) {
1720                         $_has_math = true;
1721                         if(!empty($_complete_var) || is_numeric($_complete_var)) {
1722                             $_output .= $this->_parse_var($_complete_var);
1723                         }
1724
1725                         // just output the math operator to php
1726                         $_output .= $_math_var;
1727
1728                         if(empty($_first_var))
1729                             $_first_var = $_complete_var;
1730
1731                         $_complete_var = "";
1732                     } else {
1733                         $_complete_var .= $_math_var;
1734                     }
1735                 }
1736             }
1737             if($_has_math) {
1738                 if(!empty($_complete_var) || is_numeric($_complete_var))
1739                     $_output .= $this->_parse_var($_complete_var);
1740
1741                 // get the modifiers working (only the last var from math + modifier is left)
1742                 $var_expr = $_complete_var;
1743             }
1744         }
1745
1746         // prevent cutting of first digit in the number (we _definitly_ got a number if the first char is a digit)
1747         if(is_numeric(substr($var_expr, 0, 1)))
1748             $_var_ref = $var_expr;
1749         else
1750             $_var_ref = substr($var_expr, 1);
1751
1752         if(!$_has_math) {
1753
1754             // get [foo] and .foo and ->foo and (...) pieces
1755             preg_match_all('~(?:^\w+)|' . $this->_obj_params_regexp . '|(?:' . $this->_var_bracket_regexp . ')|->\$?\w+|\.\$?\w+|\S+~', $_var_ref, $match);
1756
1757             $_indexes = $match[0];
1758             $_var_name = array_shift($_indexes);
1759
1760             /* Handle $smarty.* variable references as a special case. */
1761             if ($_var_name == 'smarty') {
1762                 /*
1763                  * If the reference could be compiled, use the compiled output;
1764                  * otherwise, fall back on the $smarty variable generated at
1765                  * run-time.
1766                  */
1767                 if (($smarty_ref = $this->_compile_smarty_ref($_indexes)) !== null) {
1768                     $_output = $smarty_ref;
1769                 } else {
1770                     $_var_name = substr(array_shift($_indexes), 1);
1771                     $_output = "\$this->_smarty_vars['$_var_name']";
1772                 }
1773             } elseif(is_numeric($_var_name) && is_numeric(substr($var_expr, 0, 1))) {
1774                 // because . is the operator for accessing arrays thru inidizes we need to put it together again for floating point numbers
1775                 if(count($_indexes) > 0)
1776                 {
1777                     $_var_name .= implode("", $_indexes);
1778                     $_indexes = array();
1779                 }
1780                 $_output = $_var_name;
1781             } else {
1782                 $_output = "\$this->_tpl_vars['$_var_name']";
1783             }
1784
1785             foreach ($_indexes as $_index) {
1786                 if (substr($_index, 0, 1) == '[') {
1787                     $_index = substr($_index, 1, -1);
1788                     if (is_numeric($_index)) {
1789                         $_output .= "[$_index]";
1790                     } elseif (substr($_index, 0, 1) == '$') {
1791                         if (strpos($_index, '.') !== false) {
1792                             $_output .= '[' . $this->_parse_var($_index) . ']';
1793                         } else {
1794                             $_output .= "[\$this->_tpl_vars['" . substr($_index, 1) . "']]";
1795                         }
1796                     } else {
1797                         $_var_parts = explode('.', $_index);
1798                         $_var_section = $_var_parts[0];
1799                         $_var_section_prop = isset($_var_parts[1]) ? $_var_parts[1] : 'index';
1800                         $_output .= "[\$this->_sections['$_var_section']['$_var_section_prop']]";
1801                     }
1802                 } else if (substr($_index, 0, 1) == '.') {
1803                     if (substr($_index, 1, 1) == '$')
1804                         $_output .= "[\$this->_tpl_vars['" . substr($_index, 2) . "']]";
1805                     else
1806                         $_output .= "['" . substr($_index, 1) . "']";
1807                 } else if (substr($_index,0,2) == '->') {
1808                     if(substr($_index,2,2) == '__') {
1809                         $this->_syntax_error('call to internal object members is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1810                     } elseif($this->security && substr($_index, 2, 1) == '_') {
1811                         $this->_syntax_error('(secure) call to private object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1812                     } elseif (substr($_index, 2, 1) == '$') {
1813                         if ($this->security) {
1814                             $this->_syntax_error('(secure) call to dynamic object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1815                         } else {
1816                             $_output .= '->{(($_var=$this->_tpl_vars[\''.substr($_index,3).'\']) && substr($_var,0,2)!=\'__\') ? $_var : $this->trigger_error("cannot access property \\"$_var\\"")}';
1817                         }
1818                     } else {
1819                         $_output .= $_index;
1820                     }
1821                 } elseif (substr($_index, 0, 1) == '(') {
1822                     $_index = $this->_parse_parenth_args($_index);
1823                     $_output .= $_index;
1824                 } else {
1825                     $_output .= $_index;
1826                 }
1827             }
1828         }
1829
1830         return $_output;
1831     }
1832
1833     /**
1834      * parse arguments in function call parenthesis
1835      *
1836      * @param string $parenth_args
1837      * @return string
1838      */
1839     function _parse_parenth_args($parenth_args)
1840     {
1841         preg_match_all('~' . $this->_param_regexp . '~',$parenth_args, $match);
1842         $orig_vals = $match = $match[0];
1843         $this->_parse_vars_props($match);
1844         $replace = array();
1845         for ($i = 0, $count = count($match); $i < $count; $i++) {
1846             $replace[$orig_vals[$i]] = $match[$i];
1847         }
1848         return strtr($parenth_args, $replace);
1849     }
1850
1851     /**
1852      * parse configuration variable expression into PHP code
1853      *
1854      * @param string $conf_var_expr
1855      */
1856     function _parse_conf_var($conf_var_expr)
1857     {
1858         $parts = explode('|', $conf_var_expr, 2);
1859         $var_ref = $parts[0];
1860         $modifiers = isset($parts[1]) ? $parts[1] : '';
1861
1862         $var_name = substr($var_ref, 1, -1);
1863
1864         $output = "\$this->_config[0]['vars']['$var_name']";
1865
1866         $this->_parse_modifiers($output, $modifiers);
1867
1868         return $output;
1869     }
1870
1871     /**
1872      * parse section property expression into PHP code
1873      *
1874      * @param string $section_prop_expr
1875      * @return string
1876      */
1877     function _parse_section_prop($section_prop_expr)
1878     {
1879         $parts = explode('|', $section_prop_expr, 2);
1880         $var_ref = $parts[0];
1881         $modifiers = isset($parts[1]) ? $parts[1] : '';
1882
1883         preg_match('!%(\w+)\.(\w+)%!', $var_ref, $match);
1884         $section_name = $match[1];
1885         $prop_name = $match[2];
1886
1887         $output = "\$this->_sections['$section_name']['$prop_name']";
1888
1889         $this->_parse_modifiers($output, $modifiers);
1890
1891         return $output;
1892     }
1893
1894
1895     /**
1896      * parse modifier chain into PHP code
1897      *
1898      * sets $output to parsed modified chain
1899      * @param string $output
1900      * @param string $modifier_string
1901      */
1902     function _parse_modifiers(&$output, $modifier_string)
1903     {
1904         preg_match_all('~\|(@?\w+)((?>:(?:'. $this->_qstr_regexp . '|[^|]+))*)~', '|' . $modifier_string, $_match);
1905         list(, $_modifiers, $modifier_arg_strings) = $_match;
1906
1907         for ($_i = 0, $_for_max = count($_modifiers); $_i < $_for_max; $_i++) {
1908             $_modifier_name = $_modifiers[$_i];
1909
1910             if($_modifier_name == 'smarty') {
1911                 // skip smarty modifier
1912                 continue;
1913             }
1914
1915             preg_match_all('~:(' . $this->_qstr_regexp . '|[^:]+)~', $modifier_arg_strings[$_i], $_match);
1916             $_modifier_args = $_match[1];
1917
1918             if (substr($_modifier_name, 0, 1) == '@') {
1919                 $_map_array = false;
1920                 $_modifier_name = substr($_modifier_name, 1);
1921             } else {
1922                 $_map_array = true;
1923             }
1924
1925             if (empty($this->_plugins['modifier'][$_modifier_name])
1926                 && !$this->_get_plugin_filepath('modifier', $_modifier_name)
1927                 && function_exists($_modifier_name)) {
1928                 if ($this->security && !in_array($_modifier_name, $this->security_settings['MODIFIER_FUNCS'])) {
1929                     $this->_trigger_fatal_error("[plugin] (secure mode) modifier '$_modifier_name' is not allowed" , $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
1930                 } else {
1931                     $this->_plugins['modifier'][$_modifier_name] = array($_modifier_name,  null, null, false);
1932                 }
1933             }
1934             $this->_add_plugin('modifier', $_modifier_name);
1935
1936             $this->_parse_vars_props($_modifier_args);
1937
1938             if($_modifier_name == 'default') {
1939                 // supress notifications of default modifier vars and args
1940                 if(substr($output, 0, 1) == '$') {
1941                     $output = '@' . $output;
1942                 }
1943                 if(isset($_modifier_args[0]) && substr($_modifier_args[0], 0, 1) == '$') {
1944                     $_modifier_args[0] = '@' . $_modifier_args[0];
1945                 }
1946             }
1947             if (count($_modifier_args) > 0)
1948                 $_modifier_args = ', '.implode(', ', $_modifier_args);
1949             else
1950                 $_modifier_args = '';
1951
1952             if ($_map_array) {
1953                 $output = "((is_array(\$_tmp=$output)) ? \$this->_run_mod_handler('$_modifier_name', true, \$_tmp$_modifier_args) : " . $this->_compile_plugin_call('modifier', $_modifier_name) . "(\$_tmp$_modifier_args))";
1954
1955             } else {
1956
1957                 $output = $this->_compile_plugin_call('modifier', $_modifier_name)."($output$_modifier_args)";
1958
1959             }
1960         }
1961     }
1962
1963
1964     /**
1965      * add plugin
1966      *
1967      * @param string $type
1968      * @param string $name
1969      * @param boolean? $delayed_loading
1970      */
1971     function _add_plugin($type, $name, $delayed_loading = null)
1972     {
1973         if (!isset($this->_plugin_info[$type])) {
1974             $this->_plugin_info[$type] = array();
1975         }
1976         if (!isset($this->_plugin_info[$type][$name])) {
1977             $this->_plugin_info[$type][$name] = array($this->_current_file,
1978                                                       $this->_current_line_no,
1979                                                       $delayed_loading);
1980         }
1981     }
1982
1983
1984     /**
1985      * Compiles references of type $smarty.foo
1986      *
1987      * @param string $indexes
1988      * @return string
1989      */
1990     function _compile_smarty_ref(&$indexes)
1991     {
1992         /* Extract the reference name. */
1993         $_ref = substr($indexes[0], 1);
1994         foreach($indexes as $_index_no=>$_index) {
1995             if (substr($_index, 0, 1) != '.' && $_index_no<2 || !preg_match('~^(\.|\[|->)~', $_index)) {
1996                 $this->_syntax_error('$smarty' . implode('', array_slice($indexes, 0, 2)) . ' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
1997             }
1998         }
1999
2000         switch ($_ref) {
2001             case 'now':
2002                 $compiled_ref = 'time()';
2003                 $_max_index = 1;
2004                 break;
2005
2006             case 'foreach':
2007                 array_shift($indexes);
2008                 $_var = $this->_parse_var_props(substr($indexes[0], 1));
2009                 $_propname = substr($indexes[1], 1);
2010                 $_max_index = 1;
2011                 switch ($_propname) {
2012                     case 'index':
2013                         array_shift($indexes);
2014                         $compiled_ref = "(\$this->_foreach[$_var]['iteration']-1)";
2015                         break;
2016
2017                     case 'first':
2018                         array_shift($indexes);
2019                         $compiled_ref = "(\$this->_foreach[$_var]['iteration'] <= 1)";
2020                         break;
2021
2022                     case 'last':
2023                         array_shift($indexes);
2024                         $compiled_ref = "(\$this->_foreach[$_var]['iteration'] == \$this->_foreach[$_var]['total'])";
2025                         break;
2026
2027                     case 'show':
2028                         array_shift($indexes);
2029                         $compiled_ref = "(\$this->_foreach[$_var]['total'] > 0)";
2030                         break;
2031
2032                     default:
2033                         unset($_max_index);
2034                         $compiled_ref = "\$this->_foreach[$_var]";
2035                 }
2036                 break;
2037
2038             case 'section':
2039                 array_shift($indexes);
2040                 $_var = $this->_parse_var_props(substr($indexes[0], 1));
2041                 $compiled_ref = "\$this->_sections[$_var]";
2042                 break;
2043
2044             case 'get':
2045                 $compiled_ref = ($this->request_use_auto_globals) ? '$_GET' : "\$GLOBALS['HTTP_GET_VARS']";
2046                 break;
2047
2048             case 'post':
2049                 $compiled_ref = ($this->request_use_auto_globals) ? '$_POST' : "\$GLOBALS['HTTP_POST_VARS']";
2050                 break;
2051
2052             case 'cookies':
2053                 $compiled_ref = ($this->request_use_auto_globals) ? '$_COOKIE' : "\$GLOBALS['HTTP_COOKIE_VARS']";
2054                 break;
2055
2056             case 'env':
2057                 $compiled_ref = ($this->request_use_auto_globals) ? '$_ENV' : "\$GLOBALS['HTTP_ENV_VARS']";
2058                 break;
2059
2060             case 'server':
2061                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SERVER' : "\$GLOBALS['HTTP_SERVER_VARS']";
2062                 break;
2063
2064             case 'session':
2065                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SESSION' : "\$GLOBALS['HTTP_SESSION_VARS']";
2066                 break;
2067
2068             /*
2069              * These cases are handled either at run-time or elsewhere in the
2070              * compiler.
2071              */
2072             case 'request':
2073                 if ($this->request_use_auto_globals) {
2074                     $compiled_ref = '$_REQUEST';
2075                     break;
2076                 } else {
2077                     $this->_init_smarty_vars = true;
2078                 }
2079                 return null;
2080
2081             case 'capture':
2082                 return null;
2083
2084             case 'template':
2085                 $compiled_ref = "'$this->_current_file'";
2086                 $_max_index = 1;
2087                 break;
2088
2089             case 'version':
2090                 $compiled_ref = "'$this->_version'";
2091                 $_max_index = 1;
2092                 break;
2093
2094             case 'const':
2095                 if ($this->security && !$this->security_settings['ALLOW_CONSTANTS']) {
2096                     $this->_syntax_error("(secure mode) constants not permitted",
2097                                          E_USER_WARNING, __FILE__, __LINE__);
2098                     return;
2099                 }
2100                 array_shift($indexes);
2101                 if (preg_match('!^\.\w+$!', $indexes[0])) {
2102                     $compiled_ref = '@' . substr($indexes[0], 1);
2103                 } else {
2104                     $_val = $this->_parse_var_props(substr($indexes[0], 1));
2105                     $compiled_ref = '@constant(' . $_val . ')';
2106                 }
2107                 $_max_index = 1;
2108                 break;
2109
2110             case 'config':
2111                 $compiled_ref = "\$this->_config[0]['vars']";
2112                 $_max_index = 3;
2113                 break;
2114
2115             case 'ldelim':
2116                 $compiled_ref = "'$this->left_delimiter'";
2117                 break;
2118
2119             case 'rdelim':
2120                 $compiled_ref = "'$this->right_delimiter'";
2121                 break;
2122
2123             default:
2124                 $this->_syntax_error('$smarty.' . $_ref . ' is an unknown reference', E_USER_ERROR, __FILE__, __LINE__);
2125                 break;
2126         }
2127
2128         if (isset($_max_index) && count($indexes) > $_max_index) {
2129             $this->_syntax_error('$smarty' . implode('', $indexes) .' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
2130         }
2131
2132         array_shift($indexes);
2133         return $compiled_ref;
2134     }
2135
2136     /**
2137      * compiles call to plugin of type $type with name $name
2138      * returns a string containing the function-name or method call
2139      * without the paramter-list that would have follow to make the
2140      * call valid php-syntax
2141      *
2142      * @param string $type
2143      * @param string $name
2144      * @return string
2145      */
2146     function _compile_plugin_call($type, $name) {
2147         if (isset($this->_plugins[$type][$name])) {
2148             /* plugin loaded */
2149             if (is_array($this->_plugins[$type][$name][0])) {
2150                 return ((is_object($this->_plugins[$type][$name][0][0])) ?
2151                         "\$this->_plugins['$type']['$name'][0][0]->"    /* method callback */
2152                         : (string)($this->_plugins[$type][$name][0][0]).'::'    /* class callback */
2153                        ). $this->_plugins[$type][$name][0][1];
2154
2155             } else {
2156                 /* function callback */
2157                 return $this->_plugins[$type][$name][0];
2158
2159             }
2160         } else {
2161             /* plugin not loaded -> auto-loadable-plugin */
2162             return 'smarty_'.$type.'_'.$name;
2163
2164         }
2165     }
2166
2167     /**
2168      * load pre- and post-filters
2169      */
2170     function _load_filters()
2171     {
2172         if (count($this->_plugins['prefilter']) > 0) {
2173             foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
2174                 if ($prefilter === false) {
2175                     unset($this->_plugins['prefilter'][$filter_name]);
2176                     $_params = array('plugins' => array(array('prefilter', $filter_name, null, null, false)));
2177                     require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
2178                     smarty_core_load_plugins($_params, $this);
2179                 }
2180             }
2181         }
2182         if (count($this->_plugins['postfilter']) > 0) {
2183             foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
2184                 if ($postfilter === false) {
2185                     unset($this->_plugins['postfilter'][$filter_name]);
2186                     $_params = array('plugins' => array(array('postfilter', $filter_name, null, null, false)));
2187                     require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
2188                     smarty_core_load_plugins($_params, $this);
2189                 }
2190             }
2191         }
2192     }
2193
2194
2195     /**
2196      * Quote subpattern references
2197      *
2198      * @param string $string
2199      * @return string
2200      */
2201     function _quote_replace($string)
2202     {
2203         return strtr($string, array('\\' => '\\\\', '$' => '\\$'));
2204     }
2205
2206     /**
2207      * display Smarty syntax error
2208      *
2209      * @param string $error_msg
2210      * @param integer $error_type
2211      * @param string $file
2212      * @param integer $line
2213      */
2214     function _syntax_error($error_msg, $error_type = E_USER_ERROR, $file=null, $line=null)
2215     {
2216         $this->_trigger_fatal_error("syntax error: $error_msg", $this->_current_file, $this->_current_line_no, $file, $line, $error_type);
2217     }
2218
2219
2220     /**
2221      * check if the compilation changes from cacheable to
2222      * non-cacheable state with the beginning of the current
2223      * plugin. return php-code to reflect the transition.
2224      * @return string
2225      */
2226     function _push_cacheable_state($type, $name) {
2227         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
2228         if ($_cacheable
2229             || 0<$this->_cacheable_state++) return '';
2230         if (!isset($this->_cache_serial)) $this->_cache_serial = md5(uniqid('Smarty'));
2231         $_ret = 'if ($this->caching && !$this->_cache_including): echo \'{nocache:'
2232             . $this->_cache_serial . '#' . $this->_nocache_count
2233             . '}\'; endif;';
2234         return $_ret;
2235     }
2236
2237
2238     /**
2239      * check if the compilation changes from non-cacheable to
2240      * cacheable state with the end of the current plugin return
2241      * php-code to reflect the transition.
2242      * @return string
2243      */
2244     function _pop_cacheable_state($type, $name) {
2245         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
2246         if ($_cacheable
2247             || --$this->_cacheable_state>0) return '';
2248         return 'if ($this->caching && !$this->_cache_including): echo \'{/nocache:'
2249             . $this->_cache_serial . '#' . ($this->_nocache_count++)
2250             . '}\'; endif;';
2251     }
2252
2253
2254     /**
2255      * push opening tag-name, file-name and line-number on the tag-stack
2256      * @param string the opening tag's name
2257      */
2258     function _push_tag($open_tag)
2259     {
2260         array_push($this->_tag_stack, array($open_tag, $this->_current_line_no));
2261     }
2262
2263     /**
2264      * pop closing tag-name
2265      * raise an error if this stack-top doesn't match with the closing tag
2266      * @param string the closing tag's name
2267      * @return string the opening tag's name
2268      */
2269     function _pop_tag($close_tag)
2270     {
2271         $message = '';
2272         if (count($this->_tag_stack)>0) {
2273             list($_open_tag, $_line_no) = array_pop($this->_tag_stack);
2274             if ($close_tag == $_open_tag) {
2275                 return $_open_tag;
2276             }
2277             if ($close_tag == 'if' && ($_open_tag == 'else' || $_open_tag == 'elseif' )) {
2278                 return $this->_pop_tag($close_tag);
2279             }
2280             if ($close_tag == 'section' && $_open_tag == 'sectionelse') {
2281                 $this->_pop_tag($close_tag);
2282                 return $_open_tag;
2283             }
2284             if ($close_tag == 'foreach' && $_open_tag == 'foreachelse') {
2285                 $this->_pop_tag($close_tag);
2286                 return $_open_tag;
2287             }
2288             if ($_open_tag == 'else' || $_open_tag == 'elseif') {
2289                 $_open_tag = 'if';
2290             } elseif ($_open_tag == 'sectionelse') {
2291                 $_open_tag = 'section';
2292             } elseif ($_open_tag == 'foreachelse') {
2293                 $_open_tag = 'foreach';
2294             }
2295             $message = " expected {/$_open_tag} (opened line $_line_no).";
2296         }
2297         $this->_syntax_error("mismatched tag {/$close_tag}.$message",
2298                              E_USER_ERROR, __FILE__, __LINE__);
2299     }
2300
2301 }
2302
2303 /**
2304  * compare to values by their string length
2305  *
2306  * @access private
2307  * @param string $a
2308  * @param string $b
2309  * @return 0|-1|1
2310  */
2311 function _smarty_sort_length($a, $b)
2312 {
2313     if($a == $b)
2314         return 0;
2315
2316     if(strlen($a) == strlen($b))
2317         return ($a > $b) ? -1 : 1;
2318
2319     return (strlen($a) > strlen($b)) ? -1 : 1;
2320 }
2321
2322
2323 /* vim: set et: */
2324
2325 ?>