av/includes/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.18
  25  * @copyright 2001-2005 New Digital Group, Inc.
  26  * @package Smarty
  27  */
  28
  29 /* $Id: Smarty_Compiler.class.php,v 1.395 2007/03/06 10:40:06 messju Exp $ */
  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 = 'null';
 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             if (isset($attrs['name']))
1226                 $buffer = $attrs['name'];
1227             else
1228                 $buffer = "'default'";
1229
1230             if (isset($attrs['assign']))
1231                 $assign = $attrs['assign'];
1232             else
1233                 $assign = null;
1234             $output = "<?php ob_start(); ?>";
1235             $this->_capture_stack[] = array($buffer, $assign);
1236         } else {
1237             list($buffer, $assign) = array_pop($this->_capture_stack);
1238             $output = "<?php \$this->_smarty_vars['capture'][$buffer] = ob_get_contents(); ";
1239             if (isset($assign)) {
1240                 $output .= " \$this->assign($assign, ob_get_contents());";
1241             }
1242             $output .= "ob_end_clean(); ?>";
1243         }
1244
1245         return $output;
1246     }
1247
1248     /**
1249      * Compile {if ...} tag
1250      *
1251      * @param string $tag_args
1252      * @param boolean $elseif if true, uses elseif instead of if
1253      * @return string
1254      */
1255     function _compile_if_tag($tag_args, $elseif = false)
1256     {
1257
1258         /* Tokenize args for 'if' tag. */
1259         preg_match_all('~(?>
1260                 ' . $this->_obj_call_regexp . '(?:' . $this->_mod_regexp . '*)? | # valid object call
1261                 ' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)?    | # var or quoted string
1262                 \-?0[xX][0-9a-fA-F]+|\-?\d+(?:\.\d+)?|\.\d+|!==|===|==|!=|<>|<<|>>|<=|>=|\&\&|\|\||\(|\)|,|\!|\^|=|\&|\~|<|>|\||\%|\+|\-|\/|\*|\@    | # valid non-word token
1263                 \b\w+\b                                                        | # valid word token
1264                 \S+                                                           # anything else
1265                 )~x', $tag_args, $match);
1266
1267         $tokens = $match[0];
1268
1269         if(empty($tokens)) {
1270             $_error_msg = $elseif ? "'elseif'" : "'if'";
1271             $_error_msg .= ' statement requires arguments';
1272             $this->_syntax_error($_error_msg, E_USER_ERROR, __FILE__, __LINE__);
1273         }
1274
1275
1276         // make sure we have balanced parenthesis
1277         $token_count = array_count_values($tokens);
1278         if(isset($token_count['(']) && $token_count['('] != $token_count[')']) {
1279             $this->_syntax_error("unbalanced parenthesis in if statement", E_USER_ERROR, __FILE__, __LINE__);
1280         }
1281
1282         $is_arg_stack = array();
1283
1284         for ($i = 0; $i < count($tokens); $i++) {
1285
1286             $token = &$tokens[$i];
1287
1288             switch (strtolower($token)) {
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                 case '/':
1314                 case '@':
1315                     break;
1316
1317                 case 'eq':
1318                     $token = '==';
1319                     break;
1320
1321                 case 'ne':
1322                 case 'neq':
1323                     $token = '!=';
1324                     break;
1325
1326                 case 'lt':
1327                     $token = '<';
1328                     break;
1329
1330                 case 'le':
1331                 case 'lte':
1332                     $token = '<=';
1333                     break;
1334
1335                 case 'gt':
1336                     $token = '>';
1337                     break;
1338
1339                 case 'ge':
1340                 case 'gte':
1341                     $token = '>=';
1342                     break;
1343
1344                 case 'and':
1345                     $token = '&&';
1346                     break;
1347
1348                 case 'or':
1349                     $token = '||';
1350                     break;
1351
1352                 case 'not':
1353                     $token = '!';
1354                     break;
1355
1356                 case 'mod':
1357                     $token = '%';
1358                     break;
1359
1360                 case '(':
1361                     array_push($is_arg_stack, $i);
1362                     break;
1363
1364                 case 'is':
1365                     /* If last token was a ')', we operate on the parenthesized
1366                        expression. The start of the expression is on the stack.
1367                        Otherwise, we operate on the last encountered token. */
1368                     if ($tokens[$i-1] == ')')
1369                         $is_arg_start = array_pop($is_arg_stack);
1370                     else
1371                         $is_arg_start = $i-1;
1372                     /* Construct the argument for 'is' expression, so it knows
1373                        what to operate on. */
1374                     $is_arg = implode(' ', array_slice($tokens, $is_arg_start, $i - $is_arg_start));
1375
1376                     /* Pass all tokens from next one until the end to the
1377                        'is' expression parsing function. The function will
1378                        return modified tokens, where the first one is the result
1379                        of the 'is' expression and the rest are the tokens it
1380                        didn't touch. */
1381                     $new_tokens = $this->_parse_is_expr($is_arg, array_slice($tokens, $i+1));
1382
1383                     /* Replace the old tokens with the new ones. */
1384                     array_splice($tokens, $is_arg_start, count($tokens), $new_tokens);
1385
1386                     /* Adjust argument start so that it won't change from the
1387                        current position for the next iteration. */
1388                     $i = $is_arg_start;
1389                     break;
1390
1391                 default:
1392                     if(preg_match('~^' . $this->_func_regexp . '$~', $token) ) {
1393                             // function call
1394                             if($this->security &&
1395                                !in_array($token, $this->security_settings['IF_FUNCS'])) {
1396                                 $this->_syntax_error("(secure mode) '$token' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
1397                             }
1398                     } elseif(preg_match('~^' . $this->_var_regexp . '$~', $token) && (strpos('+-*/^%&|', substr($token, -1)) === false) && isset($tokens[$i+1]) && $tokens[$i+1] == '(') {
1399                         // variable function call
1400                         $this->_syntax_error("variable function call '$token' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
1401                     } elseif(preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)$~', $token)) {
1402                         // object or variable
1403                         $token = $this->_parse_var_props($token);
1404                     } elseif(is_numeric($token)) {
1405                         // number, skip it
1406                     } else {
1407                         $this->_syntax_error("unidentified token '$token'", E_USER_ERROR, __FILE__, __LINE__);
1408                     }
1409                     break;
1410             }
1411         }
1412
1413         if ($elseif)
1414             return '<?php elseif ('.implode(' ', $tokens).'): ?>';
1415         else
1416             return '<?php if ('.implode(' ', $tokens).'): ?>';
1417     }
1418
1419
1420     function _compile_arg_list($type, $name, $attrs, &$cache_code) {
1421         $arg_list = array();
1422
1423         if (isset($type) && isset($name)
1424             && isset($this->_plugins[$type])
1425             && isset($this->_plugins[$type][$name])
1426             && empty($this->_plugins[$type][$name][4])
1427             && is_array($this->_plugins[$type][$name][5])
1428             ) {
1429             /* we have a list of parameters that should be cached */
1430             $_cache_attrs = $this->_plugins[$type][$name][5];
1431             $_count = $this->_cache_attrs_count++;
1432             $cache_code = "\$_cache_attrs =& \$this->_smarty_cache_attrs('$this->_cache_serial','$_count');";
1433
1434         } else {
1435             /* no parameters are cached */
1436             $_cache_attrs = null;
1437         }
1438
1439         foreach ($attrs as $arg_name => $arg_value) {
1440             if (is_bool($arg_value))
1441                 $arg_value = $arg_value ? 'true' : 'false';
1442             if (is_null($arg_value))
1443                 $arg_value = 'null';
1444             if ($_cache_attrs && in_array($arg_name, $_cache_attrs)) {
1445                 $arg_list[] = "'$arg_name' => (\$this->_cache_including) ? \$_cache_attrs['$arg_name'] : (\$_cache_attrs['$arg_name']=$arg_value)";
1446             } else {
1447                 $arg_list[] = "'$arg_name' => $arg_value";
1448             }
1449         }
1450         return $arg_list;
1451     }
1452
1453     /**
1454      * Parse is expression
1455      *
1456      * @param string $is_arg
1457      * @param array $tokens
1458      * @return array
1459      */
1460     function _parse_is_expr($is_arg, $tokens)
1461     {
1462         $expr_end = 0;
1463         $negate_expr = false;
1464
1465         if (($first_token = array_shift($tokens)) == 'not') {
1466             $negate_expr = true;
1467             $expr_type = array_shift($tokens);
1468         } else
1469             $expr_type = $first_token;
1470
1471         switch ($expr_type) {
1472             case 'even':
1473                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
1474                     $expr_end++;
1475                     $expr_arg = $tokens[$expr_end++];
1476                     $expr = "!(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
1477                 } else
1478                     $expr = "!(1 & $is_arg)";
1479                 break;
1480
1481             case 'odd':
1482                 if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
1483                     $expr_end++;
1484                     $expr_arg = $tokens[$expr_end++];
1485                     $expr = "(1 & ($is_arg / " . $this->_parse_var_props($expr_arg) . "))";
1486                 } else
1487                     $expr = "(1 & $is_arg)";
1488                 break;
1489
1490             case 'div':
1491                 if (@$tokens[$expr_end] == 'by') {
1492                     $expr_end++;
1493                     $expr_arg = $tokens[$expr_end++];
1494                     $expr = "!($is_arg % " . $this->_parse_var_props($expr_arg) . ")";
1495                 } else {
1496                     $this->_syntax_error("expecting 'by' after 'div'", E_USER_ERROR, __FILE__, __LINE__);
1497                 }
1498                 break;
1499
1500             default:
1501                 $this->_syntax_error("unknown 'is' expression - '$expr_type'", E_USER_ERROR, __FILE__, __LINE__);
1502                 break;
1503         }
1504
1505         if ($negate_expr) {
1506             $expr = "!($expr)";
1507         }
1508
1509         array_splice($tokens, 0, $expr_end, $expr);
1510
1511         return $tokens;
1512     }
1513
1514
1515     /**
1516      * Parse attribute string
1517      *
1518      * @param string $tag_args
1519      * @return array
1520      */
1521     function _parse_attrs($tag_args)
1522     {
1523
1524         /* Tokenize tag attributes. */
1525         preg_match_all('~(?:' . $this->_obj_call_regexp . '|' . $this->_qstr_regexp . ' | (?>[^"\'=\s]+)
1526                          )+ |
1527                          [=]
1528                         ~x', $tag_args, $match);
1529         $tokens       = $match[0];
1530
1531         $attrs = array();
1532         /* Parse state:
1533             0 - expecting attribute name
1534             1 - expecting '='
1535             2 - expecting attribute value (not '=') */
1536         $state = 0;
1537
1538         foreach ($tokens as $token) {
1539             switch ($state) {
1540                 case 0:
1541                     /* If the token is a valid identifier, we set attribute name
1542                        and go to state 1. */
1543                     if (preg_match('~^\w+$~', $token)) {
1544                         $attr_name = $token;
1545                         $state = 1;
1546                     } else
1547                         $this->_syntax_error("invalid attribute name: '$token'", E_USER_ERROR, __FILE__, __LINE__);
1548                     break;
1549
1550                 case 1:
1551                     /* If the token is '=', then we go to state 2. */
1552                     if ($token == '=') {
1553                         $state = 2;
1554                     } else
1555                         $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
1556                     break;
1557
1558                 case 2:
1559                     /* If token is not '=', we set the attribute value and go to
1560                        state 0. */
1561                     if ($token != '=') {
1562                         /* We booleanize the token if it's a non-quoted possible
1563                            boolean value. */
1564                         if (preg_match('~^(on|yes|true)$~', $token)) {
1565                             $token = 'true';
1566                         } else if (preg_match('~^(off|no|false)$~', $token)) {
1567                             $token = 'false';
1568                         } else if ($token == 'null') {
1569                             $token = 'null';
1570                         } else if (preg_match('~^' . $this->_num_const_regexp . '|0[xX][0-9a-fA-F]+$~', $token)) {
1571                             /* treat integer literally */
1572                         } else if (!preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . ')*$~', $token)) {
1573                             /* treat as a string, double-quote it escaping quotes */
1574                             $token = '"'.addslashes($token).'"';
1575                         }
1576
1577                         $attrs[$attr_name] = $token;
1578                         $state = 0;
1579                     } else
1580                         $this->_syntax_error("'=' cannot be an attribute value", E_USER_ERROR, __FILE__, __LINE__);
1581                     break;
1582             }
1583             $last_token = $token;
1584         }
1585
1586         if($state != 0) {
1587             if($state == 1) {
1588                 $this->_syntax_error("expecting '=' after attribute name '$last_token'", E_USER_ERROR, __FILE__, __LINE__);
1589             } else {
1590                 $this->_syntax_error("missing attribute value", E_USER_ERROR, __FILE__, __LINE__);
1591             }
1592         }
1593
1594         $this->_parse_vars_props($attrs);
1595
1596         return $attrs;
1597     }
1598
1599     /**
1600      * compile multiple variables and section properties tokens into
1601      * PHP code
1602      *
1603      * @param array $tokens
1604      */
1605     function _parse_vars_props(&$tokens)
1606     {
1607         foreach($tokens as $key => $val) {
1608             $tokens[$key] = $this->_parse_var_props($val);
1609         }
1610     }
1611
1612     /**
1613      * compile single variable and section properties token into
1614      * PHP code
1615      *
1616      * @param string $val
1617      * @param string $tag_attrs
1618      * @return string
1619      */
1620     function _parse_var_props($val)
1621     {
1622         $val = trim($val);
1623
1624         if(preg_match('~^(' . $this->_obj_call_regexp . '|' . $this->_dvar_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match)) {
1625             // $ variable or object
1626             $return = $this->_parse_var($match[1]);
1627             $modifiers = $match[2];
1628             if (!empty($this->default_modifiers) && !preg_match('~(^|\|)smarty:nodefaults($|\|)~',$modifiers)) {
1629                 $_default_mod_string = implode('|',(array)$this->default_modifiers);
1630                 $modifiers = empty($modifiers) ? $_default_mod_string : $_default_mod_string . '|' . $modifiers;
1631             }
1632             $this->_parse_modifiers($return, $modifiers);
1633             return $return;
1634         } elseif (preg_match('~^' . $this->_db_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1635                 // double quoted text
1636                 preg_match('~^(' . $this->_db_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1637                 $return = $this->_expand_quoted_text($match[1]);
1638                 if($match[2] != '') {
1639                     $this->_parse_modifiers($return, $match[2]);
1640                 }
1641                 return $return;
1642             }
1643         elseif(preg_match('~^' . $this->_num_const_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1644                 // numerical constant
1645                 preg_match('~^(' . $this->_num_const_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1646                 if($match[2] != '') {
1647                     $this->_parse_modifiers($match[1], $match[2]);
1648                     return $match[1];
1649                 }
1650             }
1651         elseif(preg_match('~^' . $this->_si_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1652                 // single quoted text
1653                 preg_match('~^(' . $this->_si_qstr_regexp . ')('. $this->_mod_regexp . '*)$~', $val, $match);
1654                 if($match[2] != '') {
1655                     $this->_parse_modifiers($match[1], $match[2]);
1656                     return $match[1];
1657                 }
1658             }
1659         elseif(preg_match('~^' . $this->_cvar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1660                 // config var
1661                 return $this->_parse_conf_var($val);
1662             }
1663         elseif(preg_match('~^' . $this->_svar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {
1664                 // section var
1665                 return $this->_parse_section_prop($val);
1666             }
1667         elseif(!in_array($val, $this->_permitted_tokens) && !is_numeric($val)) {
1668             // literal string
1669             return $this->_expand_quoted_text('"' . strtr($val, array('\\' => '\\\\', '"' => '\\"')) .'"');
1670         }
1671         return $val;
1672     }
1673
1674     /**
1675      * expand quoted text with embedded variables
1676      *
1677      * @param string $var_expr
1678      * @return string
1679      */
1680     function _expand_quoted_text($var_expr)
1681     {
1682         // if contains unescaped $, expand it
1683         if(preg_match_all('~(?:\`(?<!\\\\)\$' . $this->_dvar_guts_regexp . '(?:' . $this->_obj_ext_regexp . ')*\`)|(?:(?<!\\\\)\$\w+(\[[a-zA-Z0-9]+\])*)~', $var_expr, $_match)) {
1684             $_match = $_match[0];
1685             $_replace = array();
1686             foreach($_match as $_var) {
1687                 $_replace[$_var] = '".(' . $this->_parse_var(str_replace('`','',$_var)) . ')."';
1688             }
1689             $var_expr = strtr($var_expr, $_replace);
1690             $_return = preg_replace('~\.""|(?<!\\\\)""\.~', '', $var_expr);
1691         } else {
1692             $_return = $var_expr;
1693         }
1694         // replace double quoted literal string with single quotes
1695         $_return = preg_replace('~^"([\s\w]+)"$~',"'\\1'",$_return);
1696         return $_return;
1697     }
1698
1699     /**
1700      * parse variable expression into PHP code
1701      *
1702      * @param string $var_expr
1703      * @param string $output
1704      * @return string
1705      */
1706     function _parse_var($var_expr)
1707     {
1708         $_has_math = false;
1709         $_math_vars = preg_split('~('.$this->_dvar_math_regexp.'|'.$this->_qstr_regexp.')~', $var_expr, -1, PREG_SPLIT_DELIM_CAPTURE);
1710
1711         if(count($_math_vars) > 1) {
1712             $_first_var = "";
1713             $_complete_var = "";
1714             $_output = "";
1715             // simple check if there is any math, to stop recursion (due to modifiers with "xx % yy" as parameter)
1716             foreach($_math_vars as $_k => $_math_var) {
1717                 $_math_var = $_math_vars[$_k];
1718
1719                 if(!empty($_math_var) || is_numeric($_math_var)) {
1720                     // hit a math operator, so process the stuff which came before it
1721                     if(preg_match('~^' . $this->_dvar_math_regexp . '$~', $_math_var)) {
1722                         $_has_math = true;
1723                         if(!empty($_complete_var) || is_numeric($_complete_var)) {
1724                             $_output .= $this->_parse_var($_complete_var);
1725                         }
1726
1727                         // just output the math operator to php
1728                         $_output .= $_math_var;
1729
1730                         if(empty($_first_var))
1731                             $_first_var = $_complete_var;
1732
1733                         $_complete_var = "";
1734                     } else {
1735                         $_complete_var .= $_math_var;
1736                     }
1737                 }
1738             }
1739             if($_has_math) {
1740                 if(!empty($_complete_var) || is_numeric($_complete_var))
1741                     $_output .= $this->_parse_var($_complete_var);
1742
1743                 // get the modifiers working (only the last var from math + modifier is left)
1744                 $var_expr = $_complete_var;
1745             }
1746         }
1747
1748         // prevent cutting of first digit in the number (we _definitly_ got a number if the first char is a digit)
1749         if(is_numeric(substr($var_expr, 0, 1)))
1750             $_var_ref = $var_expr;
1751         else
1752             $_var_ref = substr($var_expr, 1);
1753
1754         if(!$_has_math) {
1755
1756             // get [foo] and .foo and ->foo and (...) pieces
1757             preg_match_all('~(?:^\w+)|' . $this->_obj_params_regexp . '|(?:' . $this->_var_bracket_regexp . ')|->\$?\w+|\.\$?\w+|\S+~', $_var_ref, $match);
1758
1759             $_indexes = $match[0];
1760             $_var_name = array_shift($_indexes);
1761
1762             /* Handle $smarty.* variable references as a special case. */
1763             if ($_var_name == 'smarty') {
1764                 /*
1765                  * If the reference could be compiled, use the compiled output;
1766                  * otherwise, fall back on the $smarty variable generated at
1767                  * run-time.
1768                  */
1769                 if (($smarty_ref = $this->_compile_smarty_ref($_indexes)) !== null) {
1770                     $_output = $smarty_ref;
1771                 } else {
1772                     $_var_name = substr(array_shift($_indexes), 1);
1773                     $_output = "\$this->_smarty_vars['$_var_name']";
1774                 }
1775             } elseif(is_numeric($_var_name) && is_numeric(substr($var_expr, 0, 1))) {
1776                 // because . is the operator for accessing arrays thru inidizes we need to put it together again for floating point numbers
1777                 if(count($_indexes) > 0)
1778                 {
1779                     $_var_name .= implode("", $_indexes);
1780                     $_indexes = array();
1781                 }
1782                 $_output = $_var_name;
1783             } else {
1784                 $_output = "\$this->_tpl_vars['$_var_name']";
1785             }
1786
1787             foreach ($_indexes as $_index) {
1788                 if (substr($_index, 0, 1) == '[') {
1789                     $_index = substr($_index, 1, -1);
1790                     if (is_numeric($_index)) {
1791                         $_output .= "[$_index]";
1792                     } elseif (substr($_index, 0, 1) == '$') {
1793                         if (strpos($_index, '.') !== false) {
1794                             $_output .= '[' . $this->_parse_var($_index) . ']';
1795                         } else {
1796                             $_output .= "[\$this->_tpl_vars['" . substr($_index, 1) . "']]";
1797                         }
1798                     } else {
1799                         $_var_parts = explode('.', $_index);
1800                         $_var_section = $_var_parts[0];
1801                         $_var_section_prop = isset($_var_parts[1]) ? $_var_parts[1] : 'index';
1802                         $_output .= "[\$this->_sections['$_var_section']['$_var_section_prop']]";
1803                     }
1804                 } else if (substr($_index, 0, 1) == '.') {
1805                     if (substr($_index, 1, 1) == '$')
1806                         $_output .= "[\$this->_tpl_vars['" . substr($_index, 2) . "']]";
1807                     else
1808                         $_output .= "['" . substr($_index, 1) . "']";
1809                 } else if (substr($_index,0,2) == '->') {
1810                     if(substr($_index,2,2) == '__') {
1811                         $this->_syntax_error('call to internal object members is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1812                     } elseif($this->security && substr($_index, 2, 1) == '_') {
1813                         $this->_syntax_error('(secure) call to private object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1814                     } elseif (substr($_index, 2, 1) == '$') {
1815                         if ($this->security) {
1816                             $this->_syntax_error('(secure) call to dynamic object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
1817                         } else {
1818                             $_output .= '->{(($_var=$this->_tpl_vars[\''.substr($_index,3).'\']) && substr($_var,0,2)!=\'__\') ? $_var : $this->trigger_error("cannot access property \\"$_var\\"")}';
1819                         }
1820                     } else {
1821                         $_output .= $_index;
1822                     }
1823                 } elseif (substr($_index, 0, 1) == '(') {
1824                     $_index = $this->_parse_parenth_args($_index);
1825                     $_output .= $_index;
1826                 } else {
1827                     $_output .= $_index;
1828                 }
1829             }
1830         }
1831
1832         return $_output;
1833     }
1834
1835     /**
1836      * parse arguments in function call parenthesis
1837      *
1838      * @param string $parenth_args
1839      * @return string
1840      */
1841     function _parse_parenth_args($parenth_args)
1842     {
1843         preg_match_all('~' . $this->_param_regexp . '~',$parenth_args, $match);
1844         $orig_vals = $match = $match[0];
1845         $this->_parse_vars_props($match);
1846         $replace = array();
1847         for ($i = 0, $count = count($match); $i < $count; $i++) {
1848             $replace[$orig_vals[$i]] = $match[$i];
1849         }
1850         return strtr($parenth_args, $replace);
1851     }
1852
1853     /**
1854      * parse configuration variable expression into PHP code
1855      *
1856      * @param string $conf_var_expr
1857      */
1858     function _parse_conf_var($conf_var_expr)
1859     {
1860         $parts = explode('|', $conf_var_expr, 2);
1861         $var_ref = $parts[0];
1862         $modifiers = isset($parts[1]) ? $parts[1] : '';
1863
1864         $var_name = substr($var_ref, 1, -1);
1865
1866         $output = "\$this->_config[0]['vars']['$var_name']";
1867
1868         $this->_parse_modifiers($output, $modifiers);
1869
1870         return $output;
1871     }
1872
1873     /**
1874      * parse section property expression into PHP code
1875      *
1876      * @param string $section_prop_expr
1877      * @return string
1878      */
1879     function _parse_section_prop($section_prop_expr)
1880     {
1881         $parts = explode('|', $section_prop_expr, 2);
1882         $var_ref = $parts[0];
1883         $modifiers = isset($parts[1]) ? $parts[1] : '';
1884
1885         preg_match('!%(\w+)\.(\w+)%!', $var_ref, $match);
1886         $section_name = $match[1];
1887         $prop_name = $match[2];
1888
1889         $output = "\$this->_sections['$section_name']['$prop_name']";
1890
1891         $this->_parse_modifiers($output, $modifiers);
1892
1893         return $output;
1894     }
1895
1896
1897     /**
1898      * parse modifier chain into PHP code
1899      *
1900      * sets $output to parsed modified chain
1901      * @param string $output
1902      * @param string $modifier_string
1903      */
1904     function _parse_modifiers(&$output, $modifier_string)
1905     {
1906         preg_match_all('~\|(@?\w+)((?>:(?:'. $this->_qstr_regexp . '|[^|]+))*)~', '|' . $modifier_string, $_match);
1907         list(, $_modifiers, $modifier_arg_strings) = $_match;
1908
1909         for ($_i = 0, $_for_max = count($_modifiers); $_i < $_for_max; $_i++) {
1910             $_modifier_name = $_modifiers[$_i];
1911
1912             if($_modifier_name == 'smarty') {
1913                 // skip smarty modifier
1914                 continue;
1915             }
1916
1917             preg_match_all('~:(' . $this->_qstr_regexp . '|[^:]+)~', $modifier_arg_strings[$_i], $_match);
1918             $_modifier_args = $_match[1];
1919
1920             if (substr($_modifier_name, 0, 1) == '@') {
1921                 $_map_array = false;
1922                 $_modifier_name = substr($_modifier_name, 1);
1923             } else {
1924                 $_map_array = true;
1925             }
1926
1927             if (empty($this->_plugins['modifier'][$_modifier_name])
1928                 && !$this->_get_plugin_filepath('modifier', $_modifier_name)
1929                 && function_exists($_modifier_name)) {
1930                 if ($this->security && !in_array($_modifier_name, $this->security_settings['MODIFIER_FUNCS'])) {
1931                     $this->_trigger_fatal_error("[plugin] (secure mode) modifier '$_modifier_name' is not allowed" , $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
1932                 } else {
1933                     $this->_plugins['modifier'][$_modifier_name] = array($_modifier_name,  null, null, false);
1934                 }
1935             }
1936             $this->_add_plugin('modifier', $_modifier_name);
1937
1938             $this->_parse_vars_props($_modifier_args);
1939
1940             if($_modifier_name == 'default') {
1941                 // supress notifications of default modifier vars and args
1942                 if(substr($output, 0, 1) == '$') {
1943                     $output = '@' . $output;
1944                 }
1945                 if(isset($_modifier_args[0]) && substr($_modifier_args[0], 0, 1) == '$') {
1946                     $_modifier_args[0] = '@' . $_modifier_args[0];
1947                 }
1948             }
1949             if (count($_modifier_args) > 0)
1950                 $_modifier_args = ', '.implode(', ', $_modifier_args);
1951             else
1952                 $_modifier_args = '';
1953
1954             if ($_map_array) {
1955                 $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))";
1956
1957             } else {
1958
1959                 $output = $this->_compile_plugin_call('modifier', $_modifier_name)."($output$_modifier_args)";
1960
1961             }
1962         }
1963     }
1964
1965
1966     /**
1967      * add plugin
1968      *
1969      * @param string $type
1970      * @param string $name
1971      * @param boolean? $delayed_loading
1972      */
1973     function _add_plugin($type, $name, $delayed_loading = null)
1974     {
1975         if (!isset($this->_plugin_info[$type])) {
1976             $this->_plugin_info[$type] = array();
1977         }
1978         if (!isset($this->_plugin_info[$type][$name])) {
1979             $this->_plugin_info[$type][$name] = array($this->_current_file,
1980                                                       $this->_current_line_no,
1981                                                       $delayed_loading);
1982         }
1983     }
1984
1985
1986     /**
1987      * Compiles references of type $smarty.foo
1988      *
1989      * @param string $indexes
1990      * @return string
1991      */
1992     function _compile_smarty_ref(&$indexes)
1993     {
1994         /* Extract the reference name. */
1995         $_ref = substr($indexes[0], 1);
1996         foreach($indexes as $_index_no=>$_index) {
1997             if (substr($_index, 0, 1) != '.' && $_index_no<2 || !preg_match('~^(\.|\[|->)~', $_index)) {
1998                 $this->_syntax_error('$smarty' . implode('', array_slice($indexes, 0, 2)) . ' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
1999             }
2000         }
2001
2002         switch ($_ref) {
2003             case 'now':
2004                 $compiled_ref = 'time()';
2005                 $_max_index = 1;
2006                 break;
2007
2008             case 'foreach':
2009                 array_shift($indexes);
2010                 $_var = $this->_parse_var_props(substr($indexes[0], 1));
2011                 $_propname = substr($indexes[1], 1);
2012                 $_max_index = 1;
2013                 switch ($_propname) {
2014                     case 'index':
2015                         array_shift($indexes);
2016                         $compiled_ref = "(\$this->_foreach[$_var]['iteration']-1)";
2017                         break;
2018
2019                     case 'first':
2020                         array_shift($indexes);
2021                         $compiled_ref = "(\$this->_foreach[$_var]['iteration'] <= 1)";
2022                         break;
2023
2024                     case 'last':
2025                         array_shift($indexes);
2026                         $compiled_ref = "(\$this->_foreach[$_var]['iteration'] == \$this->_foreach[$_var]['total'])";
2027                         break;
2028
2029                     case 'show':
2030                         array_shift($indexes);
2031                         $compiled_ref = "(\$this->_foreach[$_var]['total'] > 0)";
2032                         break;
2033
2034                     default:
2035                         unset($_max_index);
2036                         $compiled_ref = "\$this->_foreach[$_var]";
2037                 }
2038                 break;
2039
2040             case 'section':
2041                 array_shift($indexes);
2042                 $_var = $this->_parse_var_props(substr($indexes[0], 1));
2043                 $compiled_ref = "\$this->_sections[$_var]";
2044                 break;
2045
2046             case 'get':
2047                 $compiled_ref = ($this->request_use_auto_globals) ? '$_GET' : "\$GLOBALS['HTTP_GET_VARS']";
2048                 break;
2049
2050             case 'post':
2051                 $compiled_ref = ($this->request_use_auto_globals) ? '$_POST' : "\$GLOBALS['HTTP_POST_VARS']";
2052                 break;
2053
2054             case 'cookies':
2055                 $compiled_ref = ($this->request_use_auto_globals) ? '$_COOKIE' : "\$GLOBALS['HTTP_COOKIE_VARS']";
2056                 break;
2057
2058             case 'env':
2059                 $compiled_ref = ($this->request_use_auto_globals) ? '$_ENV' : "\$GLOBALS['HTTP_ENV_VARS']";
2060                 break;
2061
2062             case 'server':
2063                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SERVER' : "\$GLOBALS['HTTP_SERVER_VARS']";
2064                 break;
2065
2066             case 'session':
2067                 $compiled_ref = ($this->request_use_auto_globals) ? '$_SESSION' : "\$GLOBALS['HTTP_SESSION_VARS']";
2068                 break;
2069
2070             /*
2071              * These cases are handled either at run-time or elsewhere in the
2072              * compiler.
2073              */
2074             case 'request':
2075                 if ($this->request_use_auto_globals) {
2076                     $compiled_ref = '$_REQUEST';
2077                     break;
2078                 } else {
2079                     $this->_init_smarty_vars = true;
2080                 }
2081                 return null;
2082
2083             case 'capture':
2084                 return null;
2085
2086             case 'template':
2087                 $compiled_ref = "'$this->_current_file'";
2088                 $_max_index = 1;
2089                 break;
2090
2091             case 'version':
2092                 $compiled_ref = "'$this->_version'";
2093                 $_max_index = 1;
2094                 break;
2095
2096             case 'const':
2097                 if ($this->security && !$this->security_settings['ALLOW_CONSTANTS']) {
2098                     $this->_syntax_error("(secure mode) constants not permitted",
2099                                          E_USER_WARNING, __FILE__, __LINE__);
2100                     return;
2101                 }
2102                 array_shift($indexes);
2103                 if (preg_match('!^\.\w+$!', $indexes[0])) {
2104                     $compiled_ref = '@' . substr($indexes[0], 1);
2105                 } else {
2106                     $_val = $this->_parse_var_props(substr($indexes[0], 1));
2107                     $compiled_ref = '@constant(' . $_val . ')';
2108                 }
2109                 $_max_index = 1;
2110                 break;
2111
2112             case 'config':
2113                 $compiled_ref = "\$this->_config[0]['vars']";
2114                 $_max_index = 3;
2115                 break;
2116
2117             case 'ldelim':
2118                 $compiled_ref = "'$this->left_delimiter'";
2119                 break;
2120
2121             case 'rdelim':
2122                 $compiled_ref = "'$this->right_delimiter'";
2123                 break;
2124
2125             default:
2126                 $this->_syntax_error('$smarty.' . $_ref . ' is an unknown reference', E_USER_ERROR, __FILE__, __LINE__);
2127                 break;
2128         }
2129
2130         if (isset($_max_index) && count($indexes) > $_max_index) {
2131             $this->_syntax_error('$smarty' . implode('', $indexes) .' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
2132         }
2133
2134         array_shift($indexes);
2135         return $compiled_ref;
2136     }
2137
2138     /**
2139      * compiles call to plugin of type $type with name $name
2140      * returns a string containing the function-name or method call
2141      * without the paramter-list that would have follow to make the
2142      * call valid php-syntax
2143      *
2144      * @param string $type
2145      * @param string $name
2146      * @return string
2147      */
2148     function _compile_plugin_call($type, $name) {
2149         if (isset($this->_plugins[$type][$name])) {
2150             /* plugin loaded */
2151             if (is_array($this->_plugins[$type][$name][0])) {
2152                 return ((is_object($this->_plugins[$type][$name][0][0])) ?
2153                         "\$this->_plugins['$type']['$name'][0][0]->"    /* method callback */
2154                         : (string)($this->_plugins[$type][$name][0][0]).'::'    /* class callback */
2155                        ). $this->_plugins[$type][$name][0][1];
2156
2157             } else {
2158                 /* function callback */
2159                 return $this->_plugins[$type][$name][0];
2160
2161             }
2162         } else {
2163             /* plugin not loaded -> auto-loadable-plugin */
2164             return 'smarty_'.$type.'_'.$name;
2165
2166         }
2167     }
2168
2169     /**
2170      * load pre- and post-filters
2171      */
2172     function _load_filters()
2173     {
2174         if (count($this->_plugins['prefilter']) > 0) {
2175             foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
2176                 if ($prefilter === false) {
2177                     unset($this->_plugins['prefilter'][$filter_name]);
2178                     $_params = array('plugins' => array(array('prefilter', $filter_name, null, null, false)));
2179                     require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
2180                     smarty_core_load_plugins($_params, $this);
2181                 }
2182             }
2183         }
2184         if (count($this->_plugins['postfilter']) > 0) {
2185             foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
2186                 if ($postfilter === false) {
2187                     unset($this->_plugins['postfilter'][$filter_name]);
2188                     $_params = array('plugins' => array(array('postfilter', $filter_name, null, null, false)));
2189                     require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');
2190                     smarty_core_load_plugins($_params, $this);
2191                 }
2192             }
2193         }
2194     }
2195
2196
2197     /**
2198      * Quote subpattern references
2199      *
2200      * @param string $string
2201      * @return string
2202      */
2203     function _quote_replace($string)
2204     {
2205         return strtr($string, array('\\' => '\\\\', '$' => '\\$'));
2206     }
2207
2208     /**
2209      * display Smarty syntax error
2210      *
2211      * @param string $error_msg
2212      * @param integer $error_type
2213      * @param string $file
2214      * @param integer $line
2215      */
2216     function _syntax_error($error_msg, $error_type = E_USER_ERROR, $file=null, $line=null)
2217     {
2218         $this->_trigger_fatal_error("syntax error: $error_msg", $this->_current_file, $this->_current_line_no, $file, $line, $error_type);
2219     }
2220
2221
2222     /**
2223      * check if the compilation changes from cacheable to
2224      * non-cacheable state with the beginning of the current
2225      * plugin. return php-code to reflect the transition.
2226      * @return string
2227      */
2228     function _push_cacheable_state($type, $name) {
2229         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
2230         if ($_cacheable
2231             || 0<$this->_cacheable_state++) return '';
2232         if (!isset($this->_cache_serial)) $this->_cache_serial = md5(uniqid('Smarty'));
2233         $_ret = 'if ($this->caching && !$this->_cache_including): echo \'{nocache:'
2234             . $this->_cache_serial . '#' . $this->_nocache_count
2235             . '}\'; endif;';
2236         return $_ret;
2237     }
2238
2239
2240     /**
2241      * check if the compilation changes from non-cacheable to
2242      * cacheable state with the end of the current plugin return
2243      * php-code to reflect the transition.
2244      * @return string
2245      */
2246     function _pop_cacheable_state($type, $name) {
2247         $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
2248         if ($_cacheable
2249             || --$this->_cacheable_state>0) return '';
2250         return 'if ($this->caching && !$this->_cache_including): echo \'{/nocache:'
2251             . $this->_cache_serial . '#' . ($this->_nocache_count++)
2252             . '}\'; endif;';
2253     }
2254
2255
2256     /**
2257      * push opening tag-name, file-name and line-number on the tag-stack
2258      * @param string the opening tag's name
2259      */
2260     function _push_tag($open_tag)
2261     {
2262         array_push($this->_tag_stack, array($open_tag, $this->_current_line_no));
2263     }
2264
2265     /**
2266      * pop closing tag-name
2267      * raise an error if this stack-top doesn't match with the closing tag
2268      * @param string the closing tag's name
2269      * @return string the opening tag's name
2270      */
2271     function _pop_tag($close_tag)
2272     {
2273         $message = '';
2274         if (count($this->_tag_stack)>0) {
2275             list($_open_tag, $_line_no) = array_pop($this->_tag_stack);
2276             if ($close_tag == $_open_tag) {
2277                 return $_open_tag;
2278             }
2279             if ($close_tag == 'if' && ($_open_tag == 'else' || $_open_tag == 'elseif' )) {
2280                 return $this->_pop_tag($close_tag);
2281             }
2282             if ($close_tag == 'section' && $_open_tag == 'sectionelse') {
2283                 $this->_pop_tag($close_tag);
2284                 return $_open_tag;
2285             }
2286             if ($close_tag == 'foreach' && $_open_tag == 'foreachelse') {
2287                 $this->_pop_tag($close_tag);
2288                 return $_open_tag;
2289             }
2290             if ($_open_tag == 'else' || $_open_tag == 'elseif') {
2291                 $_open_tag = 'if';
2292             } elseif ($_open_tag == 'sectionelse') {
2293                 $_open_tag = 'section';
2294             } elseif ($_open_tag == 'foreachelse') {
2295                 $_open_tag = 'foreach';
2296             }
2297             $message = " expected {/$_open_tag} (opened line $_line_no).";
2298         }
2299         $this->_syntax_error("mismatched tag {/$close_tag}.$message",
2300                              E_USER_ERROR, __FILE__, __LINE__);
2301     }
2302
2303 }
2304
2305 /**
2306  * compare to values by their string length
2307  *
2308  * @access private
2309  * @param string $a
2310  * @param string $b
2311  * @return 0|-1|1
2312  */
2313 function _smarty_sort_length($a, $b)
2314 {
2315     if($a == $b)
2316         return 0;
2317
2318     if(strlen($a) == strlen($b))
2319         return ($a > $b) ? -1 : 1;
2320
2321     return (strlen($a) > strlen($b)) ? -1 : 1;
2322 }
2323
2324
2325 /* vim: set et: */
2326
2327 ?>