You are here

class Smarty_Compiler in Quiz 6.5

Same name and namespace in other branches
  1. 6.6 includes/moodle/lib/smarty/Smarty_Compiler.class.php \Smarty_Compiler

Template compiling class @package Smarty

Hierarchy

Expanded class hierarchy of Smarty_Compiler

File

includes/moodle/lib/smarty/Smarty_Compiler.class.php, line 34

View source
class Smarty_Compiler extends Smarty {

  // internal vars

  /**#@+
   * @access private
   */
  var $_folded_blocks = array();

  // keeps folded template blocks
  var $_current_file = null;

  // the current template being compiled
  var $_current_line_no = 1;

  // line number for error messages
  var $_capture_stack = array();

  // keeps track of nested capture buffers
  var $_plugin_info = array();

  // keeps track of plugins to load
  var $_init_smarty_vars = false;
  var $_permitted_tokens = array(
    'true',
    'false',
    'yes',
    'no',
    'on',
    'off',
    'null',
  );
  var $_db_qstr_regexp = null;

  // regexps are setup in the constructor
  var $_si_qstr_regexp = null;
  var $_qstr_regexp = null;
  var $_func_regexp = null;
  var $_reg_obj_regexp = null;
  var $_var_bracket_regexp = null;
  var $_num_const_regexp = null;
  var $_dvar_guts_regexp = null;
  var $_dvar_regexp = null;
  var $_cvar_regexp = null;
  var $_svar_regexp = null;
  var $_avar_regexp = null;
  var $_mod_regexp = null;
  var $_var_regexp = null;
  var $_parenth_param_regexp = null;
  var $_func_call_regexp = null;
  var $_obj_ext_regexp = null;
  var $_obj_start_regexp = null;
  var $_obj_params_regexp = null;
  var $_obj_call_regexp = null;
  var $_cacheable_state = 0;
  var $_cache_attrs_count = 0;
  var $_nocache_count = 0;
  var $_cache_serial = null;
  var $_cache_include = null;
  var $_strip_depth = 0;
  var $_additional_newline = "\n";

  /**#@-*/

  /**
   * The class constructor.
   */
  function Smarty_Compiler() {

    // matches double quoted strings:
    // "foobar"
    // "foo\"bar"
    $this->_db_qstr_regexp = '"[^"\\\\]*(?:\\\\.[^"\\\\]*)*"';

    // matches single quoted strings:
    // 'foobar'
    // 'foo\'bar'
    $this->_si_qstr_regexp = '\'[^\'\\\\]*(?:\\\\.[^\'\\\\]*)*\'';

    // matches single or double quoted strings
    $this->_qstr_regexp = '(?:' . $this->_db_qstr_regexp . '|' . $this->_si_qstr_regexp . ')';

    // matches bracket portion of vars
    // [0]
    // [foo]
    // [$bar]
    $this->_var_bracket_regexp = '\\[\\$?[\\w\\.]+\\]';

    // matches numerical constants
    // 30
    // -12
    // 13.22
    $this->_num_const_regexp = '(?:\\-?\\d+(?:\\.\\d+)?)';

    // matches $ vars (not objects):
    // $foo
    // $foo.bar
    // $foo.bar.foobar
    // $foo[0]
    // $foo[$bar]
    // $foo[5][blah]
    // $foo[5].bar[$foobar][4]
    $this->_dvar_math_regexp = '(?:[\\+\\*\\/\\%]|(?:-(?!>)))';
    $this->_dvar_math_var_regexp = '[\\$\\w\\.\\+\\-\\*\\/\\%\\d\\>\\[\\]]';
    $this->_dvar_guts_regexp = '\\w+(?:' . $this->_var_bracket_regexp . ')*(?:\\.\\$?\\w+(?:' . $this->_var_bracket_regexp . ')*)*(?:' . $this->_dvar_math_regexp . '(?:' . $this->_num_const_regexp . '|' . $this->_dvar_math_var_regexp . ')*)?';
    $this->_dvar_regexp = '\\$' . $this->_dvar_guts_regexp;

    // matches config vars:
    // #foo#
    // #foobar123_foo#
    $this->_cvar_regexp = '\\#\\w+\\#';

    // matches section vars:
    // %foo.bar%
    $this->_svar_regexp = '\\%\\w+\\.\\w+\\%';

    // matches all valid variables (no quotes, no modifiers)
    $this->_avar_regexp = '(?:' . $this->_dvar_regexp . '|' . $this->_cvar_regexp . '|' . $this->_svar_regexp . ')';

    // matches valid variable syntax:
    // $foo
    // $foo
    // #foo#
    // #foo#
    // "text"
    // "text"
    $this->_var_regexp = '(?:' . $this->_avar_regexp . '|' . $this->_qstr_regexp . ')';

    // matches valid object call (one level of object nesting allowed in parameters):
    // $foo->bar
    // $foo->bar()
    // $foo->bar("text")
    // $foo->bar($foo, $bar, "text")
    // $foo->bar($foo, "foo")
    // $foo->bar->foo()
    // $foo->bar->foo->bar()
    // $foo->bar($foo->bar)
    // $foo->bar($foo->bar())
    // $foo->bar($foo->bar($blah,$foo,44,"foo",$foo[0].bar))
    $this->_obj_ext_regexp = '\\->(?:\\$?' . $this->_dvar_guts_regexp . ')';
    $this->_obj_restricted_param_regexp = '(?:' . '(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . ')(?:' . $this->_obj_ext_regexp . '(?:\\((?:(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . ')' . '(?:\\s*,\\s*(?:' . $this->_var_regexp . '|' . $this->_num_const_regexp . '))*)?\\))?)*)';
    $this->_obj_single_param_regexp = '(?:\\w+|' . $this->_obj_restricted_param_regexp . '(?:\\s*,\\s*(?:(?:\\w+|' . $this->_var_regexp . $this->_obj_restricted_param_regexp . ')))*)';
    $this->_obj_params_regexp = '\\((?:' . $this->_obj_single_param_regexp . '(?:\\s*,\\s*' . $this->_obj_single_param_regexp . ')*)?\\)';
    $this->_obj_start_regexp = '(?:' . $this->_dvar_regexp . '(?:' . $this->_obj_ext_regexp . ')+)';
    $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 . ')*)?)';

    // matches valid modifier syntax:
    // |foo
    // |@foo
    // |foo:"bar"
    // |foo:$bar
    // |foo:"bar":$foobar
    // |foo|bar
    // |foo:$foo->bar
    $this->_mod_regexp = '(?:\\|@?\\w+(?::(?:\\w+|' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_avar_regexp . '|' . $this->_qstr_regexp . '))*)';

    // matches valid function name:
    // foo123
    // _foo_bar
    $this->_func_regexp = '[a-zA-Z_]\\w*';

    // matches valid registered object:
    // foo->bar
    $this->_reg_obj_regexp = '[a-zA-Z_]\\w*->[a-zA-Z_]\\w*';

    // matches valid parameter values:
    // true
    // $foo
    // $foo|bar
    // #foo#
    // #foo#|bar
    // "text"
    // "text"|bar
    // $foo->bar
    $this->_param_regexp = '(?:\\s*(?:' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '|' . $this->_num_const_regexp . '|\\w+)(?>' . $this->_mod_regexp . '*)\\s*)';

    // matches valid parenthesised function parameters:
    //
    // "text"
    //    $foo, $bar, "text"
    // $foo|bar, "foo"|bar, $foo->bar($foo)|bar
    $this->_parenth_param_regexp = '(?:\\((?:\\w+|' . $this->_param_regexp . '(?:\\s*,\\s*(?:(?:\\w+|' . $this->_param_regexp . ')))*)?\\))';

    // matches valid function call:
    // foo()
    // foo_bar($foo)
    // _foo_bar($foo,"bar")
    // foo123($foo,$foo->bar(),"foo")
    $this->_func_call_regexp = '(?:' . $this->_func_regexp . '\\s*(?:' . $this->_parenth_param_regexp . '))';
  }

  /**
   * compile a resource
   *
   * sets $compiled_content to the compiled source
   * @param string $resource_name
   * @param string $source_content
   * @param string $compiled_content
   * @return true
   */
  function _compile_file($resource_name, $source_content, &$compiled_content) {
    if ($this->security) {

      // do not allow php syntax to be executed unless specified
      if ($this->php_handling == SMARTY_PHP_ALLOW && !$this->security_settings['PHP_HANDLING']) {
        $this->php_handling = SMARTY_PHP_PASSTHRU;
      }
    }
    $this
      ->_load_filters();
    $this->_current_file = $resource_name;
    $this->_current_line_no = 1;
    $ldq = preg_quote($this->left_delimiter, '~');
    $rdq = preg_quote($this->right_delimiter, '~');

    // run template source through prefilter functions
    if (count($this->_plugins['prefilter']) > 0) {
      foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
        if ($prefilter === false) {
          continue;
        }
        if ($prefilter[3] || is_callable($prefilter[0])) {
          $source_content = call_user_func_array($prefilter[0], array(
            $source_content,
            &$this,
          ));
          $this->_plugins['prefilter'][$filter_name][3] = true;
        }
        else {
          $this
            ->_trigger_fatal_error("[plugin] prefilter '{$filter_name}' is not implemented");
        }
      }
    }

    /* fetch all special blocks */
    $search = "~{$ldq}\\*(.*?)\\*{$rdq}|{$ldq}\\s*literal\\s*{$rdq}(.*?){$ldq}\\s*/literal\\s*{$rdq}|{$ldq}\\s*php\\s*{$rdq}(.*?){$ldq}\\s*/php\\s*{$rdq}~s";
    preg_match_all($search, $source_content, $match, PREG_SET_ORDER);
    $this->_folded_blocks = $match;
    reset($this->_folded_blocks);

    /* replace special blocks by "{php}" */
    $source_content = preg_replace($search . 'e', "'" . $this
      ->_quote_replace($this->left_delimiter) . 'php' . "' . str_repeat(\"\n\", substr_count('\\0', \"\n\")) .'" . $this
      ->_quote_replace($this->right_delimiter) . "'", $source_content);

    /* Gather all template tags. */
    preg_match_all("~{$ldq}\\s*(.*?)\\s*{$rdq}~s", $source_content, $_match);
    $template_tags = $_match[1];

    /* Split content by template tags to obtain non-template content. */
    $text_blocks = preg_split("~{$ldq}.*?{$rdq}~s", $source_content);

    /* loop through text blocks */
    for ($curr_tb = 0, $for_max = count($text_blocks); $curr_tb < $for_max; $curr_tb++) {

      /* match anything resembling php tags */
      if (preg_match_all('~(<\\?(?:\\w+|=)?|\\?>|language\\s*=\\s*[\\"\']?php[\\"\']?)~is', $text_blocks[$curr_tb], $sp_match)) {

        /* replace tags with placeholders to prevent recursive replacements */
        $sp_match[1] = array_unique($sp_match[1]);
        usort($sp_match[1], '_smarty_sort_length');
        for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
          $text_blocks[$curr_tb] = str_replace($sp_match[1][$curr_sp], '%%%SMARTYSP' . $curr_sp . '%%%', $text_blocks[$curr_tb]);
        }

        /* process each one */
        for ($curr_sp = 0, $for_max2 = count($sp_match[1]); $curr_sp < $for_max2; $curr_sp++) {
          if ($this->php_handling == SMARTY_PHP_PASSTHRU) {

            /* echo php contents */
            $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP' . $curr_sp . '%%%', '<?php echo \'' . str_replace("'", "\\'", $sp_match[1][$curr_sp]) . '\'; ?>' . "\n", $text_blocks[$curr_tb]);
          }
          else {
            if ($this->php_handling == SMARTY_PHP_QUOTE) {

              /* quote php tags */
              $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP' . $curr_sp . '%%%', htmlspecialchars($sp_match[1][$curr_sp]), $text_blocks[$curr_tb]);
            }
            else {
              if ($this->php_handling == SMARTY_PHP_REMOVE) {

                /* remove php tags */
                $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP' . $curr_sp . '%%%', '', $text_blocks[$curr_tb]);
              }
              else {

                /* SMARTY_PHP_ALLOW, but echo non php starting tags */
                $sp_match[1][$curr_sp] = preg_replace('~(<\\?(?!php|=|$))~i', '<?php echo \'\\1\'?>' . "\n", $sp_match[1][$curr_sp]);
                $text_blocks[$curr_tb] = str_replace('%%%SMARTYSP' . $curr_sp . '%%%', $sp_match[1][$curr_sp], $text_blocks[$curr_tb]);
              }
            }
          }
        }
      }
    }

    /* Compile the template tags into PHP code. */
    $compiled_tags = array();
    for ($i = 0, $for_max = count($template_tags); $i < $for_max; $i++) {
      $this->_current_line_no += substr_count($text_blocks[$i], "\n");
      $compiled_tags[] = $this
        ->_compile_tag($template_tags[$i]);
      $this->_current_line_no += substr_count($template_tags[$i], "\n");
    }
    if (count($this->_tag_stack) > 0) {
      list($_open_tag, $_line_no) = end($this->_tag_stack);
      $this
        ->_syntax_error("unclosed tag \\{{$_open_tag}} (opened line {$_line_no}).", E_USER_ERROR, __FILE__, __LINE__);
      return;
    }

    /* Reformat $text_blocks between 'strip' and '/strip' tags,
       removing spaces, tabs and newlines. */
    $strip = false;
    for ($i = 0, $for_max = count($compiled_tags); $i < $for_max; $i++) {
      if ($compiled_tags[$i] == '{strip}') {
        $compiled_tags[$i] = '';
        $strip = true;

        /* remove leading whitespaces */
        $text_blocks[$i + 1] = ltrim($text_blocks[$i + 1]);
      }
      if ($strip) {

        /* strip all $text_blocks before the next '/strip' */
        for ($j = $i + 1; $j < $for_max; $j++) {

          /* remove leading and trailing whitespaces of each line */
          $text_blocks[$j] = preg_replace('![\\t ]*[\\r\\n]+[\\t ]*!', '', $text_blocks[$j]);
          if ($compiled_tags[$j] == '{/strip}') {

            /* remove trailing whitespaces from the last text_block */
            $text_blocks[$j] = rtrim($text_blocks[$j]);
          }
          $text_blocks[$j] = "<?php echo '" . strtr($text_blocks[$j], array(
            "'" => "\\'",
            "\\" => "\\\\",
          )) . "'; ?>";
          if ($compiled_tags[$j] == '{/strip}') {
            $compiled_tags[$j] = "\n";

            /* slurped by php, but necessary
               if a newline is following the closing strip-tag */
            $strip = false;
            $i = $j;
            break;
          }
        }
      }
    }
    $compiled_content = '';

    /* Interleave the compiled contents and text blocks to get the final result. */
    for ($i = 0, $for_max = count($compiled_tags); $i < $for_max; $i++) {
      if ($compiled_tags[$i] == '') {

        // tag result empty, remove first newline from following text block
        $text_blocks[$i + 1] = preg_replace('~^(\\r\\n|\\r|\\n)~', '', $text_blocks[$i + 1]);
      }
      $compiled_content .= $text_blocks[$i] . $compiled_tags[$i];
    }
    $compiled_content .= $text_blocks[$i];

    // remove \n from the end of the file, if any
    if (($_len = strlen($compiled_content)) && $compiled_content[$_len - 1] == "\n") {
      $compiled_content = substr($compiled_content, 0, -1);
    }
    if (!empty($this->_cache_serial)) {
      $compiled_content = "<?php \$this->_cache_serials['" . $this->_cache_include . "'] = '" . $this->_cache_serial . "'; ?>" . $compiled_content;
    }

    // remove unnecessary close/open tags
    $compiled_content = preg_replace('~\\?>\\n?<\\?php~', '', $compiled_content);

    // run compiled template through postfilter functions
    if (count($this->_plugins['postfilter']) > 0) {
      foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
        if ($postfilter === false) {
          continue;
        }
        if ($postfilter[3] || is_callable($postfilter[0])) {
          $compiled_content = call_user_func_array($postfilter[0], array(
            $compiled_content,
            &$this,
          ));
          $this->_plugins['postfilter'][$filter_name][3] = true;
        }
        else {
          $this
            ->_trigger_fatal_error("Smarty plugin error: postfilter '{$filter_name}' is not implemented");
        }
      }
    }

    // put header at the top of the compiled template
    $template_header = "<?php /* Smarty version " . $this->_version . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . "\n";
    $template_header .= "         compiled from " . strtr(urlencode($resource_name), array(
      '%2F' => '/',
      '%3A' => ':',
    )) . " */ ?>\n";

    /* Emit code to load needed plugins. */
    $this->_plugins_code = '';
    if (count($this->_plugin_info)) {
      $_plugins_params = "array('plugins' => array(";
      foreach ($this->_plugin_info as $plugin_type => $plugins) {
        foreach ($plugins as $plugin_name => $plugin_info) {
          $_plugins_params .= "array('{$plugin_type}', '{$plugin_name}', '" . strtr($plugin_info[0], array(
            "'" => "\\'",
            "\\" => "\\\\",
          )) . "', {$plugin_info[1]}, ";
          $_plugins_params .= $plugin_info[2] ? 'true),' : 'false),';
        }
      }
      $_plugins_params .= '))';
      $plugins_code = "<?php require_once(SMARTY_CORE_DIR . 'core.load_plugins.php');\nsmarty_core_load_plugins({$_plugins_params}, \$this); ?>\n";
      $template_header .= $plugins_code;
      $this->_plugin_info = array();
      $this->_plugins_code = $plugins_code;
    }
    if ($this->_init_smarty_vars) {
      $template_header .= "<?php require_once(SMARTY_CORE_DIR . 'core.assign_smarty_interface.php');\nsmarty_core_assign_smarty_interface(null, \$this); ?>\n";
      $this->_init_smarty_vars = false;
    }
    $compiled_content = $template_header . $compiled_content;
    return true;
  }

  /**
   * Compile a template tag
   *
   * @param string $template_tag
   * @return string
   */
  function _compile_tag($template_tag) {

    /* Matched comment. */
    if ($template_tag[0] == '*' && $template_tag[strlen($template_tag) - 1] == '*') {
      return '';
    }

    /* Split tag into two three parts: command, command modifiers and the arguments. */
    if (!preg_match('~^(?:(' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '|\\/?' . $this->_reg_obj_regexp . '|\\/?' . $this->_func_regexp . ')(' . $this->_mod_regexp . '*))
                      (?:\\s+(.*))?$
                    ~xs', $template_tag, $match)) {
      $this
        ->_syntax_error("unrecognized tag: {$template_tag}", E_USER_ERROR, __FILE__, __LINE__);
    }
    $tag_command = $match[1];
    $tag_modifier = isset($match[2]) ? $match[2] : null;
    $tag_args = isset($match[3]) ? $match[3] : null;
    if (preg_match('~^' . $this->_num_const_regexp . '|' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '$~', $tag_command)) {

      /* tag name is a variable or object */
      $_return = $this
        ->_parse_var_props($tag_command . $tag_modifier);
      return "<?php echo {$_return}; ?>" . $this->_additional_newline;
    }

    /* If the tag name is a registered object, we process it. */
    if (preg_match('~^\\/?' . $this->_reg_obj_regexp . '$~', $tag_command)) {
      return $this
        ->_compile_registered_object_tag($tag_command, $this
        ->_parse_attrs($tag_args), $tag_modifier);
    }
    switch ($tag_command) {
      case 'include':
        return $this
          ->_compile_include_tag($tag_args);
      case 'include_php':
        return $this
          ->_compile_include_php_tag($tag_args);
      case 'if':
        $this
          ->_push_tag('if');
        return $this
          ->_compile_if_tag($tag_args);
      case 'else':
        list($_open_tag) = end($this->_tag_stack);
        if ($_open_tag != 'if' && $_open_tag != 'elseif') {
          $this
            ->_syntax_error('unexpected {else}', E_USER_ERROR, __FILE__, __LINE__);
        }
        else {
          $this
            ->_push_tag('else');
        }
        return '<?php else: ?>';
      case 'elseif':
        list($_open_tag) = end($this->_tag_stack);
        if ($_open_tag != 'if' && $_open_tag != 'elseif') {
          $this
            ->_syntax_error('unexpected {elseif}', E_USER_ERROR, __FILE__, __LINE__);
        }
        if ($_open_tag == 'if') {
          $this
            ->_push_tag('elseif');
        }
        return $this
          ->_compile_if_tag($tag_args, true);
      case '/if':
        $this
          ->_pop_tag('if');
        return '<?php endif; ?>';
      case 'capture':
        return $this
          ->_compile_capture_tag(true, $tag_args);
      case '/capture':
        return $this
          ->_compile_capture_tag(false);
      case 'ldelim':
        return $this->left_delimiter;
      case 'rdelim':
        return $this->right_delimiter;
      case 'section':
        $this
          ->_push_tag('section');
        return $this
          ->_compile_section_start($tag_args);
      case 'sectionelse':
        $this
          ->_push_tag('sectionelse');
        return "<?php endfor; else: ?>";
        break;
      case '/section':
        $_open_tag = $this
          ->_pop_tag('section');
        if ($_open_tag == 'sectionelse') {
          return "<?php endif; ?>";
        }
        else {
          return "<?php endfor; endif; ?>";
        }
      case 'foreach':
        $this
          ->_push_tag('foreach');
        return $this
          ->_compile_foreach_start($tag_args);
        break;
      case 'foreachelse':
        $this
          ->_push_tag('foreachelse');
        return "<?php endforeach; else: ?>";
      case '/foreach':
        $_open_tag = $this
          ->_pop_tag('foreach');
        if ($_open_tag == 'foreachelse') {
          return "<?php endif; unset(\$_from); ?>";
        }
        else {
          return "<?php endforeach; endif; unset(\$_from); ?>";
        }
        break;
      case 'strip':
      case '/strip':
        if ($tag_command[0] == '/') {
          $this
            ->_pop_tag('strip');
          if (--$this->_strip_depth == 0) {

            /* outermost closing {/strip} */
            $this->_additional_newline = "\n";
            return '{' . $tag_command . '}';
          }
        }
        else {
          $this
            ->_push_tag('strip');
          if ($this->_strip_depth++ == 0) {

            /* outermost opening {strip} */
            $this->_additional_newline = "";
            return '{' . $tag_command . '}';
          }
        }
        return '';
      case 'php':

        /* handle folded tags replaced by {php} */
        list(, $block) = each($this->_folded_blocks);
        $this->_current_line_no += substr_count($block[0], "\n");

        /* the number of matched elements in the regexp in _compile_file()
           determins the type of folded tag that was found */
        switch (count($block)) {
          case 2:

            /* comment */
            return '';
          case 3:

            /* literal */
            return "<?php echo '" . strtr($block[2], array(
              "'" => "\\'",
              "\\" => "\\\\",
            )) . "'; ?>" . $this->_additional_newline;
          case 4:

            /* php */
            if ($this->security && !$this->security_settings['PHP_TAGS']) {
              $this
                ->_syntax_error("(secure mode) php tags not permitted", E_USER_WARNING, __FILE__, __LINE__);
              return;
            }
            return '<?php ' . $block[3] . ' ?>';
        }
        break;
      case 'insert':
        return $this
          ->_compile_insert_tag($tag_args);
      default:
        if ($this
          ->_compile_compiler_tag($tag_command, $tag_args, $output)) {
          return $output;
        }
        else {
          if ($this
            ->_compile_block_tag($tag_command, $tag_args, $tag_modifier, $output)) {
            return $output;
          }
          else {
            if ($this
              ->_compile_custom_tag($tag_command, $tag_args, $tag_modifier, $output)) {
              return $output;
            }
            else {
              $this
                ->_syntax_error("unrecognized tag '{$tag_command}'", E_USER_ERROR, __FILE__, __LINE__);
            }
          }
        }
    }
  }

  /**
   * compile the custom compiler tag
   *
   * sets $output to the compiled custom compiler tag
   * @param string $tag_command
   * @param string $tag_args
   * @param string $output
   * @return boolean
   */
  function _compile_compiler_tag($tag_command, $tag_args, &$output) {
    $found = false;
    $have_function = true;

    /*
     * First we check if the compiler function has already been registered
     * or loaded from a plugin file.
     */
    if (isset($this->_plugins['compiler'][$tag_command])) {
      $found = true;
      $plugin_func = $this->_plugins['compiler'][$tag_command][0];
      if (!is_callable($plugin_func)) {
        $message = "compiler function '{$tag_command}' is not implemented";
        $have_function = false;
      }
    }
    else {
      if ($plugin_file = $this
        ->_get_plugin_filepath('compiler', $tag_command)) {
        $found = true;
        include_once $plugin_file;
        $plugin_func = 'smarty_compiler_' . $tag_command;
        if (!is_callable($plugin_func)) {
          $message = "plugin function {$plugin_func}() not found in {$plugin_file}\n";
          $have_function = false;
        }
        else {
          $this->_plugins['compiler'][$tag_command] = array(
            $plugin_func,
            null,
            null,
            null,
            true,
          );
        }
      }
    }

    /*
     * True return value means that we either found a plugin or a
     * dynamically registered function. False means that we didn't and the
     * compiler should now emit code to load custom function plugin for this
     * tag.
     */
    if ($found) {
      if ($have_function) {
        $output = call_user_func_array($plugin_func, array(
          $tag_args,
          &$this,
        ));
        if ($output != '') {
          $output = '<?php ' . $this
            ->_push_cacheable_state('compiler', $tag_command) . $output . $this
            ->_pop_cacheable_state('compiler', $tag_command) . ' ?>';
        }
      }
      else {
        $this
          ->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
      }
      return true;
    }
    else {
      return false;
    }
  }

  /**
   * compile block function tag
   *
   * sets $output to compiled block function tag
   * @param string $tag_command
   * @param string $tag_args
   * @param string $tag_modifier
   * @param string $output
   * @return boolean
   */
  function _compile_block_tag($tag_command, $tag_args, $tag_modifier, &$output) {
    if ($tag_command[0] == '/') {
      $start_tag = false;
      $tag_command = substr($tag_command, 1);
    }
    else {
      $start_tag = true;
    }
    $found = false;
    $have_function = true;

    /*
     * First we check if the block function has already been registered
     * or loaded from a plugin file.
     */
    if (isset($this->_plugins['block'][$tag_command])) {
      $found = true;
      $plugin_func = $this->_plugins['block'][$tag_command][0];
      if (!is_callable($plugin_func)) {
        $message = "block function '{$tag_command}' is not implemented";
        $have_function = false;
      }
    }
    else {
      if ($plugin_file = $this
        ->_get_plugin_filepath('block', $tag_command)) {
        $found = true;
        include_once $plugin_file;
        $plugin_func = 'smarty_block_' . $tag_command;
        if (!function_exists($plugin_func)) {
          $message = "plugin function {$plugin_func}() not found in {$plugin_file}\n";
          $have_function = false;
        }
        else {
          $this->_plugins['block'][$tag_command] = array(
            $plugin_func,
            null,
            null,
            null,
            true,
          );
        }
      }
    }
    if (!$found) {
      return false;
    }
    else {
      if (!$have_function) {
        $this
          ->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
        return true;
      }
    }

    /*
     * Even though we've located the plugin function, compilation
     * happens only once, so the plugin will still need to be loaded
     * at runtime for future requests.
     */
    $this
      ->_add_plugin('block', $tag_command);
    if ($start_tag) {
      $this
        ->_push_tag($tag_command);
    }
    else {
      $this
        ->_pop_tag($tag_command);
    }
    if ($start_tag) {
      $output = '<?php ' . $this
        ->_push_cacheable_state('block', $tag_command);
      $attrs = $this
        ->_parse_attrs($tag_args);
      $arg_list = $this
        ->_compile_arg_list('block', $tag_command, $attrs, $_cache_attrs = '');
      $output .= "{$_cache_attrs}\$this->_tag_stack[] = array('{$tag_command}', array(" . implode(',', $arg_list) . ')); ';
      $output .= $this
        ->_compile_plugin_call('block', $tag_command) . '($this->_tag_stack[count($this->_tag_stack)-1][1], null, $this, $_block_repeat=true);';
      $output .= 'while ($_block_repeat) { ob_start(); ?>';
    }
    else {
      $output = '<?php $_block_content = ob_get_contents(); ob_end_clean(); ';
      $_out_tag_text = $this
        ->_compile_plugin_call('block', $tag_command) . '($this->_tag_stack[count($this->_tag_stack)-1][1], $_block_content, $this, $_block_repeat=false)';
      if ($tag_modifier != '') {
        $this
          ->_parse_modifiers($_out_tag_text, $tag_modifier);
      }
      $output .= 'echo ' . $_out_tag_text . '; } ';
      $output .= " array_pop(\$this->_tag_stack); " . $this
        ->_pop_cacheable_state('block', $tag_command) . '?>';
    }
    return true;
  }

  /**
   * compile custom function tag
   *
   * @param string $tag_command
   * @param string $tag_args
   * @param string $tag_modifier
   * @return string
   */
  function _compile_custom_tag($tag_command, $tag_args, $tag_modifier, &$output) {
    $found = false;
    $have_function = true;

    /*
     * First we check if the custom function has already been registered
     * or loaded from a plugin file.
     */
    if (isset($this->_plugins['function'][$tag_command])) {
      $found = true;
      $plugin_func = $this->_plugins['function'][$tag_command][0];
      if (!is_callable($plugin_func)) {
        $message = "custom function '{$tag_command}' is not implemented";
        $have_function = false;
      }
    }
    else {
      if ($plugin_file = $this
        ->_get_plugin_filepath('function', $tag_command)) {
        $found = true;
        include_once $plugin_file;
        $plugin_func = 'smarty_function_' . $tag_command;
        if (!function_exists($plugin_func)) {
          $message = "plugin function {$plugin_func}() not found in {$plugin_file}\n";
          $have_function = false;
        }
        else {
          $this->_plugins['function'][$tag_command] = array(
            $plugin_func,
            null,
            null,
            null,
            true,
          );
        }
      }
    }
    if (!$found) {
      return false;
    }
    else {
      if (!$have_function) {
        $this
          ->_syntax_error($message, E_USER_WARNING, __FILE__, __LINE__);
        return true;
      }
    }

    /* declare plugin to be loaded on display of the template that
       we compile right now */
    $this
      ->_add_plugin('function', $tag_command);
    $_cacheable_state = $this
      ->_push_cacheable_state('function', $tag_command);
    $attrs = $this
      ->_parse_attrs($tag_args);
    $arg_list = $this
      ->_compile_arg_list('function', $tag_command, $attrs, $_cache_attrs = '');
    $output = $this
      ->_compile_plugin_call('function', $tag_command) . '(array(' . implode(',', $arg_list) . "), \$this)";
    if ($tag_modifier != '') {
      $this
        ->_parse_modifiers($output, $tag_modifier);
    }
    if ($output != '') {
      $output = '<?php ' . $_cacheable_state . $_cache_attrs . 'echo ' . $output . ';' . $this
        ->_pop_cacheable_state('function', $tag_command) . "?>" . $this->_additional_newline;
    }
    return true;
  }

  /**
   * compile a registered object tag
   *
   * @param string $tag_command
   * @param array $attrs
   * @param string $tag_modifier
   * @return string
   */
  function _compile_registered_object_tag($tag_command, $attrs, $tag_modifier) {
    if ($tag_command[0] == '/') {
      $start_tag = false;
      $tag_command = substr($tag_command, 1);
    }
    else {
      $start_tag = true;
    }
    list($object, $obj_comp) = explode('->', $tag_command);
    $arg_list = array();
    if (count($attrs)) {
      $_assign_var = false;
      foreach ($attrs as $arg_name => $arg_value) {
        if ($arg_name == 'assign') {
          $_assign_var = $arg_value;
          unset($attrs['assign']);
          continue;
        }
        if (is_bool($arg_value)) {
          $arg_value = $arg_value ? 'true' : 'false';
        }
        $arg_list[] = "'{$arg_name}' => {$arg_value}";
      }
    }
    if ($this->_reg_objects[$object][2]) {

      // smarty object argument format
      $args = "array(" . implode(',', (array) $arg_list) . "), \$this";
    }
    else {

      // traditional argument format
      $args = implode(',', array_values($attrs));
      if (empty($args)) {
        $args = 'null';
      }
    }
    $prefix = '';
    $postfix = '';
    $newline = '';
    if (!is_object($this->_reg_objects[$object][0])) {
      $this
        ->_trigger_fatal_error("registered '{$object}' is not an object", $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
    }
    elseif (!empty($this->_reg_objects[$object][1]) && !in_array($obj_comp, $this->_reg_objects[$object][1])) {
      $this
        ->_trigger_fatal_error("'{$obj_comp}' is not a registered component of object '{$object}'", $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
    }
    elseif (method_exists($this->_reg_objects[$object][0], $obj_comp)) {

      // method
      if (in_array($obj_comp, $this->_reg_objects[$object][3])) {

        // block method
        if ($start_tag) {
          $prefix = "\$this->_tag_stack[] = array('{$obj_comp}', {$args}); ";
          $prefix .= "\$this->_reg_objects['{$object}'][0]->{$obj_comp}(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], null, \$this, \$_block_repeat=true); ";
          $prefix .= "while (\$_block_repeat) { ob_start();";
          $return = null;
          $postfix = '';
        }
        else {
          $prefix = "\$_obj_block_content = ob_get_contents(); ob_end_clean(); ";
          $return = "\$this->_reg_objects['{$object}'][0]->{$obj_comp}(\$this->_tag_stack[count(\$this->_tag_stack)-1][1], \$_obj_block_content, \$this, \$_block_repeat=false)";
          $postfix = "} array_pop(\$this->_tag_stack);";
        }
      }
      else {

        // non-block method
        $return = "\$this->_reg_objects['{$object}'][0]->{$obj_comp}({$args})";
      }
    }
    else {

      // property
      $return = "\$this->_reg_objects['{$object}'][0]->{$obj_comp}";
    }
    if ($return != null) {
      if ($tag_modifier != '') {
        $this
          ->_parse_modifiers($return, $tag_modifier);
      }
      if (!empty($_assign_var)) {
        $output = "\$this->assign('" . $this
          ->_dequote($_assign_var) . "',  {$return});";
      }
      else {
        $output = 'echo ' . $return . ';';
        $newline = $this->_additional_newline;
      }
    }
    else {
      $output = '';
    }
    return '<?php ' . $prefix . $output . $postfix . "?>" . $newline;
  }

  /**
   * Compile {insert ...} tag
   *
   * @param string $tag_args
   * @return string
   */
  function _compile_insert_tag($tag_args) {
    $attrs = $this
      ->_parse_attrs($tag_args);
    $name = $this
      ->_dequote($attrs['name']);
    if (empty($name)) {
      $this
        ->_syntax_error("missing insert name", E_USER_ERROR, __FILE__, __LINE__);
    }
    if (!empty($attrs['script'])) {
      $delayed_loading = true;
    }
    else {
      $delayed_loading = false;
    }
    foreach ($attrs as $arg_name => $arg_value) {
      if (is_bool($arg_value)) {
        $arg_value = $arg_value ? 'true' : 'false';
      }
      $arg_list[] = "'{$arg_name}' => {$arg_value}";
    }
    $this
      ->_add_plugin('insert', $name, $delayed_loading);
    $_params = "array('args' => array(" . implode(', ', (array) $arg_list) . "))";
    return "<?php require_once(SMARTY_CORE_DIR . 'core.run_insert_handler.php');\necho smarty_core_run_insert_handler({$_params}, \$this); ?>" . $this->_additional_newline;
  }

  /**
   * Compile {include ...} tag
   *
   * @param string $tag_args
   * @return string
   */
  function _compile_include_tag($tag_args) {
    $attrs = $this
      ->_parse_attrs($tag_args);
    $arg_list = array();
    if (empty($attrs['file'])) {
      $this
        ->_syntax_error("missing 'file' attribute in include tag", E_USER_ERROR, __FILE__, __LINE__);
    }
    foreach ($attrs as $arg_name => $arg_value) {
      if ($arg_name == 'file') {
        $include_file = $arg_value;
        continue;
      }
      else {
        if ($arg_name == 'assign') {
          $assign_var = $arg_value;
          continue;
        }
      }
      if (is_bool($arg_value)) {
        $arg_value = $arg_value ? 'true' : 'false';
      }
      $arg_list[] = "'{$arg_name}' => {$arg_value}";
    }
    $output = '<?php ';
    if (isset($assign_var)) {
      $output .= "ob_start();\n";
    }
    $output .= "\$_smarty_tpl_vars = \$this->_tpl_vars;\n";
    $_params = "array('smarty_include_tpl_file' => " . $include_file . ", 'smarty_include_vars' => array(" . implode(',', (array) $arg_list) . "))";
    $output .= "\$this->_smarty_include({$_params});\n" . "\$this->_tpl_vars = \$_smarty_tpl_vars;\n" . "unset(\$_smarty_tpl_vars);\n";
    if (isset($assign_var)) {
      $output .= "\$this->assign(" . $assign_var . ", ob_get_contents()); ob_end_clean();\n";
    }
    $output .= ' ?>';
    return $output;
  }

  /**
   * Compile {include ...} tag
   *
   * @param string $tag_args
   * @return string
   */
  function _compile_include_php_tag($tag_args) {
    $attrs = $this
      ->_parse_attrs($tag_args);
    if (empty($attrs['file'])) {
      $this
        ->_syntax_error("missing 'file' attribute in include_php tag", E_USER_ERROR, __FILE__, __LINE__);
    }
    $assign_var = empty($attrs['assign']) ? '' : $this
      ->_dequote($attrs['assign']);
    $once_var = empty($attrs['once']) || $attrs['once'] == 'false' ? 'false' : 'true';
    $arg_list = array();
    foreach ($attrs as $arg_name => $arg_value) {
      if ($arg_name != 'file' and $arg_name != 'once' and $arg_name != 'assign') {
        if (is_bool($arg_value)) {
          $arg_value = $arg_value ? 'true' : 'false';
        }
        $arg_list[] = "'{$arg_name}' => {$arg_value}";
      }
    }
    $_params = "array('smarty_file' => " . $attrs['file'] . ", 'smarty_assign' => '{$assign_var}', 'smarty_once' => {$once_var}, 'smarty_include_vars' => array(" . implode(',', $arg_list) . "))";
    return "<?php require_once(SMARTY_CORE_DIR . 'core.smarty_include_php.php');\nsmarty_core_smarty_include_php({$_params}, \$this); ?>" . $this->_additional_newline;
  }

  /**
   * Compile {section ...} tag
   *
   * @param string $tag_args
   * @return string
   */
  function _compile_section_start($tag_args) {
    $attrs = $this
      ->_parse_attrs($tag_args);
    $arg_list = array();
    $output = '<?php ';
    $section_name = $attrs['name'];
    if (empty($section_name)) {
      $this
        ->_syntax_error("missing section name", E_USER_ERROR, __FILE__, __LINE__);
    }
    $output .= "unset(\$this->_sections[{$section_name}]);\n";
    $section_props = "\$this->_sections[{$section_name}]";
    foreach ($attrs as $attr_name => $attr_value) {
      switch ($attr_name) {
        case 'loop':
          $output .= "{$section_props}['loop'] = is_array(\$_loop={$attr_value}) ? count(\$_loop) : max(0, (int)\$_loop); unset(\$_loop);\n";
          break;
        case 'show':
          if (is_bool($attr_value)) {
            $show_attr_value = $attr_value ? 'true' : 'false';
          }
          else {
            $show_attr_value = "(bool){$attr_value}";
          }
          $output .= "{$section_props}['show'] = {$show_attr_value};\n";
          break;
        case 'name':
          $output .= "{$section_props}['{$attr_name}'] = {$attr_value};\n";
          break;
        case 'max':
        case 'start':
          $output .= "{$section_props}['{$attr_name}'] = (int){$attr_value};\n";
          break;
        case 'step':
          $output .= "{$section_props}['{$attr_name}'] = ((int){$attr_value}) == 0 ? 1 : (int){$attr_value};\n";
          break;
        default:
          $this
            ->_syntax_error("unknown section attribute - '{$attr_name}'", E_USER_ERROR, __FILE__, __LINE__);
          break;
      }
    }
    if (!isset($attrs['show'])) {
      $output .= "{$section_props}['show'] = true;\n";
    }
    if (!isset($attrs['loop'])) {
      $output .= "{$section_props}['loop'] = 1;\n";
    }
    if (!isset($attrs['max'])) {
      $output .= "{$section_props}['max'] = {$section_props}['loop'];\n";
    }
    else {
      $output .= "if ({$section_props}['max'] < 0)\n" . "    {$section_props}['max'] = {$section_props}['loop'];\n";
    }
    if (!isset($attrs['step'])) {
      $output .= "{$section_props}['step'] = 1;\n";
    }
    if (!isset($attrs['start'])) {
      $output .= "{$section_props}['start'] = {$section_props}['step'] > 0 ? 0 : {$section_props}['loop']-1;\n";
    }
    else {
      $output .= "if ({$section_props}['start'] < 0)\n" . "    {$section_props}['start'] = max({$section_props}['step'] > 0 ? 0 : -1, {$section_props}['loop'] + {$section_props}['start']);\n" . "else\n" . "    {$section_props}['start'] = min({$section_props}['start'], {$section_props}['step'] > 0 ? {$section_props}['loop'] : {$section_props}['loop']-1);\n";
    }
    $output .= "if ({$section_props}['show']) {\n";
    if (!isset($attrs['start']) && !isset($attrs['step']) && !isset($attrs['max'])) {
      $output .= "    {$section_props}['total'] = {$section_props}['loop'];\n";
    }
    else {
      $output .= "    {$section_props}['total'] = min(ceil(({$section_props}['step'] > 0 ? {$section_props}['loop'] - {$section_props}['start'] : {$section_props}['start']+1)/abs({$section_props}['step'])), {$section_props}['max']);\n";
    }
    $output .= "    if ({$section_props}['total'] == 0)\n" . "        {$section_props}['show'] = false;\n" . "} else\n" . "    {$section_props}['total'] = 0;\n";
    $output .= "if ({$section_props}['show']):\n";
    $output .= "\n            for ({$section_props}['index'] = {$section_props}['start'], {$section_props}['iteration'] = 1;\n                 {$section_props}['iteration'] <= {$section_props}['total'];\n                 {$section_props}['index'] += {$section_props}['step'], {$section_props}['iteration']++):\n";
    $output .= "{$section_props}['rownum'] = {$section_props}['iteration'];\n";
    $output .= "{$section_props}['index_prev'] = {$section_props}['index'] - {$section_props}['step'];\n";
    $output .= "{$section_props}['index_next'] = {$section_props}['index'] + {$section_props}['step'];\n";
    $output .= "{$section_props}['first']      = ({$section_props}['iteration'] == 1);\n";
    $output .= "{$section_props}['last']       = ({$section_props}['iteration'] == {$section_props}['total']);\n";
    $output .= "?>";
    return $output;
  }

  /**
   * Compile {foreach ...} tag.
   *
   * @param string $tag_args
   * @return string
   */
  function _compile_foreach_start($tag_args) {
    $attrs = $this
      ->_parse_attrs($tag_args);
    $arg_list = array();
    if (empty($attrs['from'])) {
      return $this
        ->_syntax_error("foreach: missing 'from' attribute", E_USER_ERROR, __FILE__, __LINE__);
    }
    $from = $attrs['from'];
    if (empty($attrs['item'])) {
      return $this
        ->_syntax_error("foreach: missing 'item' attribute", E_USER_ERROR, __FILE__, __LINE__);
    }
    $item = $this
      ->_dequote($attrs['item']);
    if (!preg_match('~^\\w+$~', $item)) {
      return $this
        ->_syntax_error("'foreach: item' must be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
    }
    if (isset($attrs['key'])) {
      $key = $this
        ->_dequote($attrs['key']);
      if (!preg_match('~^\\w+$~', $key)) {
        return $this
          ->_syntax_error("foreach: 'key' must to be a variable name (literal string)", E_USER_ERROR, __FILE__, __LINE__);
      }
      $key_part = "\$this->_tpl_vars['{$key}'] => ";
    }
    else {
      $key = null;
      $key_part = '';
    }
    if (isset($attrs['name'])) {
      $name = $attrs['name'];
    }
    else {
      $name = null;
    }
    $output = '<?php ';
    $output .= "\$_from = {$from}; if (!is_array(\$_from) && !is_object(\$_from)) { settype(\$_from, 'array'); }";
    if (isset($name)) {
      $foreach_props = "\$this->_foreach[{$name}]";
      $output .= "{$foreach_props} = array('total' => count(\$_from), 'iteration' => 0);\n";
      $output .= "if ({$foreach_props}['total'] > 0):\n";
      $output .= "    foreach (\$_from as {$key_part}\$this->_tpl_vars['{$item}']):\n";
      $output .= "        {$foreach_props}['iteration']++;\n";
    }
    else {
      $output .= "if (count(\$_from)):\n";
      $output .= "    foreach (\$_from as {$key_part}\$this->_tpl_vars['{$item}']):\n";
    }
    $output .= '?>';
    return $output;
  }

  /**
   * Compile {capture} .. {/capture} tags
   *
   * @param boolean $start true if this is the {capture} tag
   * @param string $tag_args
   * @return string
   */
  function _compile_capture_tag($start, $tag_args = '') {
    $attrs = $this
      ->_parse_attrs($tag_args);
    if ($start) {
      if (isset($attrs['name'])) {
        $buffer = $attrs['name'];
      }
      else {
        $buffer = "'default'";
      }
      if (isset($attrs['assign'])) {
        $assign = $attrs['assign'];
      }
      else {
        $assign = null;
      }
      $output = "<?php ob_start(); ?>";
      $this->_capture_stack[] = array(
        $buffer,
        $assign,
      );
    }
    else {
      list($buffer, $assign) = array_pop($this->_capture_stack);
      $output = "<?php \$this->_smarty_vars['capture'][{$buffer}] = ob_get_contents(); ";
      if (isset($assign)) {
        $output .= " \$this->assign({$assign}, ob_get_contents());";
      }
      $output .= "ob_end_clean(); ?>";
    }
    return $output;
  }

  /**
   * Compile {if ...} tag
   *
   * @param string $tag_args
   * @param boolean $elseif if true, uses elseif instead of if
   * @return string
   */
  function _compile_if_tag($tag_args, $elseif = false) {

    /* Tokenize args for 'if' tag. */
    preg_match_all('~(?>
                ' . $this->_obj_call_regexp . '(?:' . $this->_mod_regexp . '*)? | # valid object call
                ' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)?    | # var or quoted string
                \\-?0[xX][0-9a-fA-F]+|\\-?\\d+(?:\\.\\d+)?|\\.\\d+|!==|===|==|!=|<>|<<|>>|<=|>=|\\&\\&|\\|\\||\\(|\\)|,|\\!|\\^|=|\\&|\\~|<|>|\\||\\%|\\+|\\-|\\/|\\*|\\@    | # valid non-word token
                \\b\\w+\\b                                                        | # valid word token
                \\S+                                                           # anything else
                )~x', $tag_args, $match);
    $tokens = $match[0];

    // make sure we have balanced parenthesis
    $token_count = array_count_values($tokens);
    if (isset($token_count['(']) && $token_count['('] != $token_count[')']) {
      $this
        ->_syntax_error("unbalanced parenthesis in if statement", E_USER_ERROR, __FILE__, __LINE__);
    }
    $is_arg_stack = array();
    for ($i = 0; $i < count($tokens); $i++) {
      $token =& $tokens[$i];
      switch (strtolower($token)) {
        case '!':
        case '%':
        case '!==':
        case '==':
        case '===':
        case '>':
        case '<':
        case '!=':
        case '<>':
        case '<<':
        case '>>':
        case '<=':
        case '>=':
        case '&&':
        case '||':
        case '|':
        case '^':
        case '&':
        case '~':
        case ')':
        case ',':
        case '+':
        case '-':
        case '*':
        case '/':
        case '@':
          break;
        case 'eq':
          $token = '==';
          break;
        case 'ne':
        case 'neq':
          $token = '!=';
          break;
        case 'lt':
          $token = '<';
          break;
        case 'le':
        case 'lte':
          $token = '<=';
          break;
        case 'gt':
          $token = '>';
          break;
        case 'ge':
        case 'gte':
          $token = '>=';
          break;
        case 'and':
          $token = '&&';
          break;
        case 'or':
          $token = '||';
          break;
        case 'not':
          $token = '!';
          break;
        case 'mod':
          $token = '%';
          break;
        case '(':
          array_push($is_arg_stack, $i);
          break;
        case 'is':

          /* If last token was a ')', we operate on the parenthesized
             expression. The start of the expression is on the stack.
             Otherwise, we operate on the last encountered token. */
          if ($tokens[$i - 1] == ')') {
            $is_arg_start = array_pop($is_arg_stack);
          }
          else {
            $is_arg_start = $i - 1;
          }

          /* Construct the argument for 'is' expression, so it knows
             what to operate on. */
          $is_arg = implode(' ', array_slice($tokens, $is_arg_start, $i - $is_arg_start));

          /* Pass all tokens from next one until the end to the
             'is' expression parsing function. The function will
             return modified tokens, where the first one is the result
             of the 'is' expression and the rest are the tokens it
             didn't touch. */
          $new_tokens = $this
            ->_parse_is_expr($is_arg, array_slice($tokens, $i + 1));

          /* Replace the old tokens with the new ones. */
          array_splice($tokens, $is_arg_start, count($tokens), $new_tokens);

          /* Adjust argument start so that it won't change from the
             current position for the next iteration. */
          $i = $is_arg_start;
          break;
        default:
          if (preg_match('~^' . $this->_func_regexp . '$~', $token)) {

            // function call
            if ($this->security && !in_array($token, $this->security_settings['IF_FUNCS'])) {
              $this
                ->_syntax_error("(secure mode) '{$token}' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
            }
          }
          elseif (preg_match('~^' . $this->_var_regexp . '$~', $token) && isset($tokens[$i + 1]) && $tokens[$i + 1] == '(') {

            // variable function call
            $this
              ->_syntax_error("variable function call '{$token}' not allowed in if statement", E_USER_ERROR, __FILE__, __LINE__);
          }
          elseif (preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . '*)$~', $token)) {

            // object or variable
            $token = $this
              ->_parse_var_props($token);
          }
          elseif (is_numeric($token)) {

            // number, skip it
          }
          else {
            $this
              ->_syntax_error("unidentified token '{$token}'", E_USER_ERROR, __FILE__, __LINE__);
          }
          break;
      }
    }
    if ($elseif) {
      return '<?php elseif (' . implode(' ', $tokens) . '): ?>';
    }
    else {
      return '<?php if (' . implode(' ', $tokens) . '): ?>';
    }
  }
  function _compile_arg_list($type, $name, $attrs, &$cache_code) {
    $arg_list = array();
    if (isset($type) && isset($name) && isset($this->_plugins[$type]) && isset($this->_plugins[$type][$name]) && empty($this->_plugins[$type][$name][4]) && is_array($this->_plugins[$type][$name][5])) {

      /* we have a list of parameters that should be cached */
      $_cache_attrs = $this->_plugins[$type][$name][5];
      $_count = $this->_cache_attrs_count++;
      $cache_code = "\$_cache_attrs =& \$this->_smarty_cache_attrs('{$this->_cache_serial}','{$_count}');";
    }
    else {

      /* no parameters are cached */
      $_cache_attrs = null;
    }
    foreach ($attrs as $arg_name => $arg_value) {
      if (is_bool($arg_value)) {
        $arg_value = $arg_value ? 'true' : 'false';
      }
      if (is_null($arg_value)) {
        $arg_value = 'null';
      }
      if ($_cache_attrs && in_array($arg_name, $_cache_attrs)) {
        $arg_list[] = "'{$arg_name}' => (\$this->_cache_including) ? \$_cache_attrs['{$arg_name}'] : (\$_cache_attrs['{$arg_name}']={$arg_value})";
      }
      else {
        $arg_list[] = "'{$arg_name}' => {$arg_value}";
      }
    }
    return $arg_list;
  }

  /**
   * Parse is expression
   *
   * @param string $is_arg
   * @param array $tokens
   * @return array
   */
  function _parse_is_expr($is_arg, $tokens) {
    $expr_end = 0;
    $negate_expr = false;
    if (($first_token = array_shift($tokens)) == 'not') {
      $negate_expr = true;
      $expr_type = array_shift($tokens);
    }
    else {
      $expr_type = $first_token;
    }
    switch ($expr_type) {
      case 'even':
        if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
          $expr_end++;
          $expr_arg = $tokens[$expr_end++];
          $expr = "!(1 & ({$is_arg} / " . $this
            ->_parse_var_props($expr_arg) . "))";
        }
        else {
          $expr = "!(1 & {$is_arg})";
        }
        break;
      case 'odd':
        if (isset($tokens[$expr_end]) && $tokens[$expr_end] == 'by') {
          $expr_end++;
          $expr_arg = $tokens[$expr_end++];
          $expr = "(1 & ({$is_arg} / " . $this
            ->_parse_var_props($expr_arg) . "))";
        }
        else {
          $expr = "(1 & {$is_arg})";
        }
        break;
      case 'div':
        if (@$tokens[$expr_end] == 'by') {
          $expr_end++;
          $expr_arg = $tokens[$expr_end++];
          $expr = "!({$is_arg} % " . $this
            ->_parse_var_props($expr_arg) . ")";
        }
        else {
          $this
            ->_syntax_error("expecting 'by' after 'div'", E_USER_ERROR, __FILE__, __LINE__);
        }
        break;
      default:
        $this
          ->_syntax_error("unknown 'is' expression - '{$expr_type}'", E_USER_ERROR, __FILE__, __LINE__);
        break;
    }
    if ($negate_expr) {
      $expr = "!({$expr})";
    }
    array_splice($tokens, 0, $expr_end, $expr);
    return $tokens;
  }

  /**
   * Parse attribute string
   *
   * @param string $tag_args
   * @return array
   */
  function _parse_attrs($tag_args) {

    /* Tokenize tag attributes. */
    preg_match_all('~(?:' . $this->_obj_call_regexp . '|' . $this->_qstr_regexp . ' | (?>[^"\'=\\s]+)
                         )+ |
                         [=]
                        ~x', $tag_args, $match);
    $tokens = $match[0];
    $attrs = array();

    /* Parse state:
       0 - expecting attribute name
       1 - expecting '='
       2 - expecting attribute value (not '=') */
    $state = 0;
    foreach ($tokens as $token) {
      switch ($state) {
        case 0:

          /* If the token is a valid identifier, we set attribute name
             and go to state 1. */
          if (preg_match('~^\\w+$~', $token)) {
            $attr_name = $token;
            $state = 1;
          }
          else {
            $this
              ->_syntax_error("invalid attribute name: '{$token}'", E_USER_ERROR, __FILE__, __LINE__);
          }
          break;
        case 1:

          /* If the token is '=', then we go to state 2. */
          if ($token == '=') {
            $state = 2;
          }
          else {
            $this
              ->_syntax_error("expecting '=' after attribute name '{$last_token}'", E_USER_ERROR, __FILE__, __LINE__);
          }
          break;
        case 2:

          /* If token is not '=', we set the attribute value and go to
             state 0. */
          if ($token != '=') {

            /* We booleanize the token if it's a non-quoted possible
               boolean value. */
            if (preg_match('~^(on|yes|true)$~', $token)) {
              $token = 'true';
            }
            else {
              if (preg_match('~^(off|no|false)$~', $token)) {
                $token = 'false';
              }
              else {
                if ($token == 'null') {
                  $token = 'null';
                }
                else {
                  if (preg_match('~^' . $this->_num_const_regexp . '|0[xX][0-9a-fA-F]+$~', $token)) {

                    /* treat integer literally */
                  }
                  else {
                    if (!preg_match('~^' . $this->_obj_call_regexp . '|' . $this->_var_regexp . '(?:' . $this->_mod_regexp . ')*$~', $token)) {

                      /* treat as a string, double-quote it escaping quotes */
                      $token = '"' . addslashes($token) . '"';
                    }
                  }
                }
              }
            }
            $attrs[$attr_name] = $token;
            $state = 0;
          }
          else {
            $this
              ->_syntax_error("'=' cannot be an attribute value", E_USER_ERROR, __FILE__, __LINE__);
          }
          break;
      }
      $last_token = $token;
    }
    if ($state != 0) {
      if ($state == 1) {
        $this
          ->_syntax_error("expecting '=' after attribute name '{$last_token}'", E_USER_ERROR, __FILE__, __LINE__);
      }
      else {
        $this
          ->_syntax_error("missing attribute value", E_USER_ERROR, __FILE__, __LINE__);
      }
    }
    $this
      ->_parse_vars_props($attrs);
    return $attrs;
  }

  /**
   * compile multiple variables and section properties tokens into
   * PHP code
   *
   * @param array $tokens
   */
  function _parse_vars_props(&$tokens) {
    foreach ($tokens as $key => $val) {
      $tokens[$key] = $this
        ->_parse_var_props($val);
    }
  }

  /**
   * compile single variable and section properties token into
   * PHP code
   *
   * @param string $val
   * @param string $tag_attrs
   * @return string
   */
  function _parse_var_props($val) {
    $val = trim($val);
    if (preg_match('~^(' . $this->_obj_call_regexp . '|' . $this->_dvar_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match)) {

      // $ variable or object
      $return = $this
        ->_parse_var($match[1]);
      $modifiers = $match[2];
      if (!empty($this->default_modifiers) && !preg_match('~(^|\\|)smarty:nodefaults($|\\|)~', $modifiers)) {
        $_default_mod_string = implode('|', (array) $this->default_modifiers);
        $modifiers = empty($modifiers) ? $_default_mod_string : $_default_mod_string . '|' . $modifiers;
      }
      $this
        ->_parse_modifiers($return, $modifiers);
      return $return;
    }
    elseif (preg_match('~^' . $this->_db_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {

      // double quoted text
      preg_match('~^(' . $this->_db_qstr_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match);
      $return = $this
        ->_expand_quoted_text($match[1]);
      if ($match[2] != '') {
        $this
          ->_parse_modifiers($return, $match[2]);
      }
      return $return;
    }
    elseif (preg_match('~^' . $this->_num_const_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {

      // numerical constant
      preg_match('~^(' . $this->_num_const_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match);
      if ($match[2] != '') {
        $this
          ->_parse_modifiers($match[1], $match[2]);
        return $match[1];
      }
    }
    elseif (preg_match('~^' . $this->_si_qstr_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {

      // single quoted text
      preg_match('~^(' . $this->_si_qstr_regexp . ')(' . $this->_mod_regexp . '*)$~', $val, $match);
      if ($match[2] != '') {
        $this
          ->_parse_modifiers($match[1], $match[2]);
        return $match[1];
      }
    }
    elseif (preg_match('~^' . $this->_cvar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {

      // config var
      return $this
        ->_parse_conf_var($val);
    }
    elseif (preg_match('~^' . $this->_svar_regexp . '(?:' . $this->_mod_regexp . '*)$~', $val)) {

      // section var
      return $this
        ->_parse_section_prop($val);
    }
    elseif (!in_array($val, $this->_permitted_tokens) && !is_numeric($val)) {

      // literal string
      return $this
        ->_expand_quoted_text('"' . $val . '"');
    }
    return $val;
  }

  /**
   * expand quoted text with embedded variables
   *
   * @param string $var_expr
   * @return string
   */
  function _expand_quoted_text($var_expr) {

    // if contains unescaped $, expand it
    if (preg_match_all('~(?:\\`(?<!\\\\)\\$' . $this->_dvar_guts_regexp . '(?:' . $this->_obj_ext_regexp . ')*\\`)|(?:(?<!\\\\)\\$\\w+(\\[[a-zA-Z0-9]+\\])*)~', $var_expr, $_match)) {
      $_match = $_match[0];
      rsort($_match);
      reset($_match);
      foreach ($_match as $_var) {
        $var_expr = str_replace($_var, '".(' . $this
          ->_parse_var(str_replace('`', '', $_var)) . ')."', $var_expr);
      }
      $_return = preg_replace('~\\.""|(?<!\\\\)""\\.~', '', $var_expr);
    }
    else {
      $_return = $var_expr;
    }

    // replace double quoted literal string with single quotes
    $_return = preg_replace('~^"([\\s\\w]+)"$~', "'\\1'", $_return);
    return $_return;
  }

  /**
   * parse variable expression into PHP code
   *
   * @param string $var_expr
   * @param string $output
   * @return string
   */
  function _parse_var($var_expr) {
    $_has_math = false;
    $_math_vars = preg_split('~(' . $this->_dvar_math_regexp . '|' . $this->_qstr_regexp . ')~', $var_expr, -1, PREG_SPLIT_DELIM_CAPTURE);
    if (count($_math_vars) > 1) {
      $_first_var = "";
      $_complete_var = "";
      $_output = "";

      // simple check if there is any math, to stop recursion (due to modifiers with "xx % yy" as parameter)
      foreach ($_math_vars as $_k => $_math_var) {
        $_math_var = $_math_vars[$_k];
        if (!empty($_math_var) || is_numeric($_math_var)) {

          // hit a math operator, so process the stuff which came before it
          if (preg_match('~^' . $this->_dvar_math_regexp . '$~', $_math_var)) {
            $_has_math = true;
            if (!empty($_complete_var) || is_numeric($_complete_var)) {
              $_output .= $this
                ->_parse_var($_complete_var);
            }

            // just output the math operator to php
            $_output .= $_math_var;
            if (empty($_first_var)) {
              $_first_var = $_complete_var;
            }
            $_complete_var = "";
          }
          else {
            $_complete_var .= $_math_var;
          }
        }
      }
      if ($_has_math) {
        if (!empty($_complete_var) || is_numeric($_complete_var)) {
          $_output .= $this
            ->_parse_var($_complete_var);
        }

        // get the modifiers working (only the last var from math + modifier is left)
        $var_expr = $_complete_var;
      }
    }

    // prevent cutting of first digit in the number (we _definitly_ got a number if the first char is a digit)
    if (is_numeric($var_expr[0])) {
      $_var_ref = $var_expr;
    }
    else {
      $_var_ref = substr($var_expr, 1);
    }
    if (!$_has_math) {

      // get [foo] and .foo and ->foo and (...) pieces
      preg_match_all('~(?:^\\w+)|' . $this->_obj_params_regexp . '|(?:' . $this->_var_bracket_regexp . ')|->\\$?\\w+|\\.\\$?\\w+|\\S+~', $_var_ref, $match);
      $_indexes = $match[0];
      $_var_name = array_shift($_indexes);

      /* Handle $smarty.* variable references as a special case. */
      if ($_var_name == 'smarty') {

        /*
         * If the reference could be compiled, use the compiled output;
         * otherwise, fall back on the $smarty variable generated at
         * run-time.
         */
        if (($smarty_ref = $this
          ->_compile_smarty_ref($_indexes)) !== null) {
          $_output = $smarty_ref;
        }
        else {
          $_var_name = substr(array_shift($_indexes), 1);
          $_output = "\$this->_smarty_vars['{$_var_name}']";
        }
      }
      elseif (is_numeric($_var_name) && is_numeric($var_expr[0])) {

        // because . is the operator for accessing arrays thru inidizes we need to put it together again for floating point numbers
        if (count($_indexes) > 0) {
          $_var_name .= implode("", $_indexes);
          $_indexes = array();
        }
        $_output = $_var_name;
      }
      else {
        $_output = "\$this->_tpl_vars['{$_var_name}']";
      }
      foreach ($_indexes as $_index) {
        if ($_index[0] == '[') {
          $_index = substr($_index, 1, -1);
          if (is_numeric($_index)) {
            $_output .= "[{$_index}]";
          }
          elseif ($_index[0] == '$') {
            if (strpos($_index, '.') !== false) {
              $_output .= '[' . $this
                ->_parse_var($_index) . ']';
            }
            else {
              $_output .= "[\$this->_tpl_vars['" . substr($_index, 1) . "']]";
            }
          }
          else {
            $_var_parts = explode('.', $_index);
            $_var_section = $_var_parts[0];
            $_var_section_prop = isset($_var_parts[1]) ? $_var_parts[1] : 'index';
            $_output .= "[\$this->_sections['{$_var_section}']['{$_var_section_prop}']]";
          }
        }
        else {
          if ($_index[0] == '.') {
            if ($_index[1] == '$') {
              $_output .= "[\$this->_tpl_vars['" . substr($_index, 2) . "']]";
            }
            else {
              $_output .= "['" . substr($_index, 1) . "']";
            }
          }
          else {
            if (substr($_index, 0, 2) == '->') {
              if (substr($_index, 2, 2) == '__') {
                $this
                  ->_syntax_error('call to internal object members is not allowed', E_USER_ERROR, __FILE__, __LINE__);
              }
              elseif ($this->security && substr($_index, 2, 1) == '_') {
                $this
                  ->_syntax_error('(secure) call to private object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
              }
              elseif ($_index[2] == '$') {
                if ($this->security) {
                  $this
                    ->_syntax_error('(secure) call to dynamic object member is not allowed', E_USER_ERROR, __FILE__, __LINE__);
                }
                else {
                  $_output .= '->{(($_var=$this->_tpl_vars[\'' . substr($_index, 3) . '\']) && substr($_var,0,2)!=\'__\') ? $_var : $this->trigger_error("cannot access property \\"$_var\\"")}';
                }
              }
              else {
                $_output .= $_index;
              }
            }
            elseif ($_index[0] == '(') {
              $_index = $this
                ->_parse_parenth_args($_index);
              $_output .= $_index;
            }
            else {
              $_output .= $_index;
            }
          }
        }
      }
    }
    return $_output;
  }

  /**
   * parse arguments in function call parenthesis
   *
   * @param string $parenth_args
   * @return string
   */
  function _parse_parenth_args($parenth_args) {
    preg_match_all('~' . $this->_param_regexp . '~', $parenth_args, $match);
    $orig_vals = $match = $match[0];
    $this
      ->_parse_vars_props($match);
    $replace = array();
    for ($i = 0, $count = count($match); $i < $count; $i++) {
      $replace[$orig_vals[$i]] = $match[$i];
    }
    return strtr($parenth_args, $replace);
  }

  /**
   * parse configuration variable expression into PHP code
   *
   * @param string $conf_var_expr
   */
  function _parse_conf_var($conf_var_expr) {
    $parts = explode('|', $conf_var_expr, 2);
    $var_ref = $parts[0];
    $modifiers = isset($parts[1]) ? $parts[1] : '';
    $var_name = substr($var_ref, 1, -1);
    $output = "\$this->_config[0]['vars']['{$var_name}']";
    $this
      ->_parse_modifiers($output, $modifiers);
    return $output;
  }

  /**
   * parse section property expression into PHP code
   *
   * @param string $section_prop_expr
   * @return string
   */
  function _parse_section_prop($section_prop_expr) {
    $parts = explode('|', $section_prop_expr, 2);
    $var_ref = $parts[0];
    $modifiers = isset($parts[1]) ? $parts[1] : '';
    preg_match('!%(\\w+)\\.(\\w+)%!', $var_ref, $match);
    $section_name = $match[1];
    $prop_name = $match[2];
    $output = "\$this->_sections['{$section_name}']['{$prop_name}']";
    $this
      ->_parse_modifiers($output, $modifiers);
    return $output;
  }

  /**
   * parse modifier chain into PHP code
   *
   * sets $output to parsed modified chain
   * @param string $output
   * @param string $modifier_string
   */
  function _parse_modifiers(&$output, $modifier_string) {
    preg_match_all('~\\|(@?\\w+)((?>:(?:' . $this->_qstr_regexp . '|[^|]+))*)~', '|' . $modifier_string, $_match);
    list(, $_modifiers, $modifier_arg_strings) = $_match;
    for ($_i = 0, $_for_max = count($_modifiers); $_i < $_for_max; $_i++) {
      $_modifier_name = $_modifiers[$_i];
      if ($_modifier_name == 'smarty') {

        // skip smarty modifier
        continue;
      }
      preg_match_all('~:(' . $this->_qstr_regexp . '|[^:]+)~', $modifier_arg_strings[$_i], $_match);
      $_modifier_args = $_match[1];
      if ($_modifier_name[0] == '@') {
        $_map_array = false;
        $_modifier_name = substr($_modifier_name, 1);
      }
      else {
        $_map_array = true;
      }
      if (empty($this->_plugins['modifier'][$_modifier_name]) && !$this
        ->_get_plugin_filepath('modifier', $_modifier_name) && function_exists($_modifier_name)) {
        if ($this->security && !in_array($_modifier_name, $this->security_settings['MODIFIER_FUNCS'])) {
          $this
            ->_trigger_fatal_error("[plugin] (secure mode) modifier '{$_modifier_name}' is not allowed", $this->_current_file, $this->_current_line_no, __FILE__, __LINE__);
        }
        else {
          $this->_plugins['modifier'][$_modifier_name] = array(
            $_modifier_name,
            null,
            null,
            false,
          );
        }
      }
      $this
        ->_add_plugin('modifier', $_modifier_name);
      $this
        ->_parse_vars_props($_modifier_args);
      if ($_modifier_name == 'default') {

        // supress notifications of default modifier vars and args
        if ($output[0] == '$') {
          $output = '@' . $output;
        }
        if (isset($_modifier_args[0]) && $_modifier_args[0][0] == '$') {
          $_modifier_args[0] = '@' . $_modifier_args[0];
        }
      }
      if (count($_modifier_args) > 0) {
        $_modifier_args = ', ' . implode(', ', $_modifier_args);
      }
      else {
        $_modifier_args = '';
      }
      if ($_map_array) {
        $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}))";
      }
      else {
        $output = $this
          ->_compile_plugin_call('modifier', $_modifier_name) . "({$output}{$_modifier_args})";
      }
    }
  }

  /**
   * add plugin
   *
   * @param string $type
   * @param string $name
   * @param boolean? $delayed_loading
   */
  function _add_plugin($type, $name, $delayed_loading = null) {
    if (!isset($this->_plugin_info[$type])) {
      $this->_plugin_info[$type] = array();
    }
    if (!isset($this->_plugin_info[$type][$name])) {
      $this->_plugin_info[$type][$name] = array(
        $this->_current_file,
        $this->_current_line_no,
        $delayed_loading,
      );
    }
  }

  /**
   * Compiles references of type $smarty.foo
   *
   * @param string $indexes
   * @return string
   */
  function _compile_smarty_ref(&$indexes) {

    /* Extract the reference name. */
    $_ref = substr($indexes[0], 1);
    foreach ($indexes as $_index_no => $_index) {
      if ($_index[0] != '.' && $_index_no < 2 || !preg_match('~^(\\.|\\[|->)~', $_index)) {
        $this
          ->_syntax_error('$smarty' . implode('', array_slice($indexes, 0, 2)) . ' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
      }
    }
    switch ($_ref) {
      case 'now':
        $compiled_ref = 'time()';
        $_max_index = 1;
        break;
      case 'foreach':
        array_shift($indexes);
        $_var = $this
          ->_parse_var_props(substr($indexes[0], 1));
        $_propname = substr($indexes[1], 1);
        $_max_index = 1;
        switch ($_propname) {
          case 'index':
            array_shift($indexes);
            $compiled_ref = "(\$this->_foreach[{$_var}]['iteration']-1)";
            break;
          case 'first':
            array_shift($indexes);
            $compiled_ref = "(\$this->_foreach[{$_var}]['iteration'] <= 1)";
            break;
          case 'last':
            array_shift($indexes);
            $compiled_ref = "(\$this->_foreach[{$_var}]['iteration'] == \$this->_foreach[{$_var}]['total'])";
            break;
          case 'show':
            array_shift($indexes);
            $compiled_ref = "(\$this->_foreach[{$_var}]['total'] > 0)";
            break;
          default:
            unset($_max_index);
            $compiled_ref = "\$this->_foreach[{$_var}]";
        }
        break;
      case 'section':
        array_shift($indexes);
        $_var = $this
          ->_parse_var_props(substr($indexes[0], 1));
        $compiled_ref = "\$this->_sections[{$_var}]";
        break;
      case 'get':
        $compiled_ref = $this->request_use_auto_globals ? '$_GET' : "\$GLOBALS['HTTP_GET_VARS']";
        break;
      case 'post':
        $compiled_ref = $this->request_use_auto_globals ? '$_POST' : "\$GLOBALS['HTTP_POST_VARS']";
        break;
      case 'cookies':
        $compiled_ref = $this->request_use_auto_globals ? '$_COOKIE' : "\$GLOBALS['HTTP_COOKIE_VARS']";
        break;
      case 'env':
        $compiled_ref = $this->request_use_auto_globals ? '$_ENV' : "\$GLOBALS['HTTP_ENV_VARS']";
        break;
      case 'server':
        $compiled_ref = $this->request_use_auto_globals ? '$_SERVER' : "\$GLOBALS['HTTP_SERVER_VARS']";
        break;
      case 'session':
        $compiled_ref = $this->request_use_auto_globals ? '$_SESSION' : "\$GLOBALS['HTTP_SESSION_VARS']";
        break;

      /*
       * These cases are handled either at run-time or elsewhere in the
       * compiler.
       */
      case 'request':
        if ($this->request_use_auto_globals) {
          $compiled_ref = '$_REQUEST';
          break;
        }
        else {
          $this->_init_smarty_vars = true;
        }
        return null;
      case 'capture':
        return null;
      case 'template':
        $compiled_ref = "'{$this->_current_file}'";
        $_max_index = 1;
        break;
      case 'version':
        $compiled_ref = "'{$this->_version}'";
        $_max_index = 1;
        break;
      case 'const':
        if ($this->security && !$this->security_settings['ALLOW_CONSTANTS']) {
          $this
            ->_syntax_error("(secure mode) constants not permitted", E_USER_WARNING, __FILE__, __LINE__);
          return;
        }
        array_shift($indexes);
        if (preg_match('!^\\.\\w+$!', $indexes[0])) {
          $compiled_ref = '@' . substr($indexes[0], 1);
        }
        else {
          $_val = $this
            ->_parse_var_props(substr($indexes[0], 1));
          $compiled_ref = '@constant(' . $_val . ')';
        }
        $_max_index = 1;
        break;
      case 'config':
        $compiled_ref = "\$this->_config[0]['vars']";
        $_max_index = 3;
        break;
      case 'ldelim':
        $compiled_ref = "'{$this->left_delimiter}'";
        break;
      case 'rdelim':
        $compiled_ref = "'{$this->right_delimiter}'";
        break;
      default:
        $this
          ->_syntax_error('$smarty.' . $_ref . ' is an unknown reference', E_USER_ERROR, __FILE__, __LINE__);
        break;
    }
    if (isset($_max_index) && count($indexes) > $_max_index) {
      $this
        ->_syntax_error('$smarty' . implode('', $indexes) . ' is an invalid reference', E_USER_ERROR, __FILE__, __LINE__);
    }
    array_shift($indexes);
    return $compiled_ref;
  }

  /**
   * compiles call to plugin of type $type with name $name
   * returns a string containing the function-name or method call
   * without the paramter-list that would have follow to make the
   * call valid php-syntax
   *
   * @param string $type
   * @param string $name
   * @return string
   */
  function _compile_plugin_call($type, $name) {
    if (isset($this->_plugins[$type][$name])) {

      /* plugin loaded */
      if (is_array($this->_plugins[$type][$name][0])) {
        return (is_object($this->_plugins[$type][$name][0][0]) ? "\$this->_plugins['{$type}']['{$name}'][0][0]->" : (string) $this->_plugins[$type][$name][0][0] . '::') . $this->_plugins[$type][$name][0][1];
      }
      else {

        /* function callback */
        return $this->_plugins[$type][$name][0];
      }
    }
    else {

      /* plugin not loaded -> auto-loadable-plugin */
      return 'smarty_' . $type . '_' . $name;
    }
  }

  /**
   * load pre- and post-filters
   */
  function _load_filters() {
    if (count($this->_plugins['prefilter']) > 0) {
      foreach ($this->_plugins['prefilter'] as $filter_name => $prefilter) {
        if ($prefilter === false) {
          unset($this->_plugins['prefilter'][$filter_name]);
          $_params = array(
            'plugins' => array(
              array(
                'prefilter',
                $filter_name,
                null,
                null,
                false,
              ),
            ),
          );
          require_once SMARTY_CORE_DIR . 'core.load_plugins.php';
          smarty_core_load_plugins($_params, $this);
        }
      }
    }
    if (count($this->_plugins['postfilter']) > 0) {
      foreach ($this->_plugins['postfilter'] as $filter_name => $postfilter) {
        if ($postfilter === false) {
          unset($this->_plugins['postfilter'][$filter_name]);
          $_params = array(
            'plugins' => array(
              array(
                'postfilter',
                $filter_name,
                null,
                null,
                false,
              ),
            ),
          );
          require_once SMARTY_CORE_DIR . 'core.load_plugins.php';
          smarty_core_load_plugins($_params, $this);
        }
      }
    }
  }

  /**
   * Quote subpattern references
   *
   * @param string $string
   * @return string
   */
  function _quote_replace($string) {
    return strtr($string, array(
      '\\' => '\\\\',
      '$' => '\\$',
    ));
  }

  /**
   * display Smarty syntax error
   *
   * @param string $error_msg
   * @param integer $error_type
   * @param string $file
   * @param integer $line
   */
  function _syntax_error($error_msg, $error_type = E_USER_ERROR, $file = null, $line = null) {
    $this
      ->_trigger_fatal_error("syntax error: {$error_msg}", $this->_current_file, $this->_current_line_no, $file, $line, $error_type);
  }

  /**
   * check if the compilation changes from cacheable to
   * non-cacheable state with the beginning of the current
   * plugin. return php-code to reflect the transition.
   * @return string
   */
  function _push_cacheable_state($type, $name) {
    $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
    if ($_cacheable || 0 < $this->_cacheable_state++) {
      return '';
    }
    if (!isset($this->_cache_serial)) {
      $this->_cache_serial = md5(uniqid('Smarty'));
    }
    $_ret = 'if ($this->caching && !$this->_cache_including) { echo \'{nocache:' . $this->_cache_serial . '#' . $this->_nocache_count . '}\';}';
    return $_ret;
  }

  /**
   * check if the compilation changes from non-cacheable to
   * cacheable state with the end of the current plugin return
   * php-code to reflect the transition.
   * @return string
   */
  function _pop_cacheable_state($type, $name) {
    $_cacheable = !isset($this->_plugins[$type][$name]) || $this->_plugins[$type][$name][4];
    if ($_cacheable || --$this->_cacheable_state > 0) {
      return '';
    }
    return 'if ($this->caching && !$this->_cache_including) { echo \'{/nocache:' . $this->_cache_serial . '#' . $this->_nocache_count++ . '}\';}';
  }

  /**
   * push opening tag-name, file-name and line-number on the tag-stack
   * @param string the opening tag's name
   */
  function _push_tag($open_tag) {
    array_push($this->_tag_stack, array(
      $open_tag,
      $this->_current_line_no,
    ));
  }

  /**
   * pop closing tag-name
   * raise an error if this stack-top doesn't match with the closing tag
   * @param string the closing tag's name
   * @return string the opening tag's name
   */
  function _pop_tag($close_tag) {
    $message = '';
    if (count($this->_tag_stack) > 0) {
      list($_open_tag, $_line_no) = array_pop($this->_tag_stack);
      if ($close_tag == $_open_tag) {
        return $_open_tag;
      }
      if ($close_tag == 'if' && ($_open_tag == 'else' || $_open_tag == 'elseif')) {
        return $this
          ->_pop_tag($close_tag);
      }
      if ($close_tag == 'section' && $_open_tag == 'sectionelse') {
        $this
          ->_pop_tag($close_tag);
        return $_open_tag;
      }
      if ($close_tag == 'foreach' && $_open_tag == 'foreachelse') {
        $this
          ->_pop_tag($close_tag);
        return $_open_tag;
      }
      if ($_open_tag == 'else' || $_open_tag == 'elseif') {
        $_open_tag = 'if';
      }
      elseif ($_open_tag == 'sectionelse') {
        $_open_tag = 'section';
      }
      elseif ($_open_tag == 'foreachelse') {
        $_open_tag = 'foreach';
      }
      $message = " expected {/{$_open_tag}} (opened line {$_line_no}).";
    }
    $this
      ->_syntax_error("mismatched tag {/{$close_tag}}.{$message}", E_USER_ERROR, __FILE__, __LINE__);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Smarty::$autoload_filters property This indicates which filters are automatically loaded into Smarty.
Smarty::$cache_dir property The name of the directory for cache files.
Smarty::$cache_handler_func property The function used for cache file handling. If not set, built-in caching is used.
Smarty::$cache_lifetime property This is the number of seconds cached content will persist. <ul> <li>0 = always regenerate cache</li> <li>-1 = never expires</li> </ul>
Smarty::$cache_modified_check property Only used when $caching is enabled. If true, then If-Modified-Since headers are respected with cached content, and appropriate HTTP headers are sent. This way repeated hits to a cached page do not send the entire page to the client every time.
Smarty::$caching property This enables template caching. <ul> <li>0 = no caching</li> <li>1 = use class cache_lifetime value</li> <li>2 = use cache_lifetime in cache file</li> </ul>
Smarty::$compiler_class property The class used for compiling templates.
Smarty::$compiler_file property The file that contains the compiler class. This can a full pathname, or relative to the php_include path.
Smarty::$compile_check property This tells Smarty whether to check for recompiling or not. Recompiling does not need to happen unless a template or config file is changed. Typically you enable this during development, and disable for production.
Smarty::$compile_dir property The directory where compiled templates are located.
Smarty::$compile_id property Set this if you want different sets of compiled files for the same templates. This is useful for things like different languages. Instead of creating separate sets of templates per language, you set different compile_ids like 'en' and…
Smarty::$config_booleanize property This tells whether or not to automatically booleanize config file variables. If enabled, then the strings "on", "true", and "yes" are treated as boolean true, and "off", "false" and "no" are…
Smarty::$config_class property The class used to load config vars.
Smarty::$config_dir property The directory where config files are located.
Smarty::$config_fix_newlines property This tells whether or not automatically fix newlines in config files. It basically converts \r (mac) or \r\n (dos) to \n
Smarty::$config_overwrite property This tells if config file vars of the same name overwrite each other or not. if disabled, same name variables are accumulated in an array.
Smarty::$config_read_hidden property This tells whether hidden sections [.foobar] are readable from the tempalates or not. Normally you would never allow this since that is the point behind hidden sections: the application can access them, but the templates cannot.
Smarty::$debugging property If debugging is enabled, a debug console window will display when the page loads (make sure your browser allows unrequested popup windows)
Smarty::$debugging_ctrl property This determines if debugging is enable-able from the browser. <ul> <li>NONE => no debugging control allowed</li> <li>URL => enable debugging when SMARTY_DEBUG is found in the URL.</li> </ul> @link…
Smarty::$debug_tpl property This is the path to the debug console template. If not set, the default one will be used.
Smarty::$default_modifiers property This is a list of the modifiers to apply to all template variables. Put each modifier in a separate array element in the order you want them applied. example: <code>array('escape:"htmlall"');</code>
Smarty::$default_resource_type property This is the resource type to be used when not specified at the beginning of the resource path. examples: $smarty->display('file:index.tpl'); $smarty->display('db:index.tpl'); $smarty->display('index.tpl'); //…
Smarty::$default_template_handler_func property If a template cannot be found, this PHP function will be executed. Useful for creating templates on-the-fly or other special action.
Smarty::$error_reporting property When set, smarty does uses this value as error_reporting-level.
Smarty::$force_compile property This forces templates to compile every time. Useful for development or debugging.
Smarty::$left_delimiter property The left delimiter used for the template tags.
Smarty::$php_handling property This determines how Smarty handles "<?php ... ?>" tags in templates. possible values: <ul> <li>SMARTY_PHP_PASSTHRU -> print tags as plain text</li> <li>SMARTY_PHP_QUOTE -> escape tags as…
Smarty::$plugins_dir property An array of directories searched for plugins.
Smarty::$request_use_auto_globals property Indicates wether $HTTP_*_VARS[] (request_use_auto_globals=false) are uses as request-vars or $_*[]-vars. note: if request_use_auto_globals is true, then $request_vars_order has no effect, but the php-ini-value "gpc_order"
Smarty::$request_vars_order property The order in which request variables are registered, similar to variables_order in php.ini E = Environment, G = GET, P = POST, C = Cookies, S = Server
Smarty::$right_delimiter property The right delimiter used for the template tags.
Smarty::$secure_dir property This is the list of template directories that are considered secure. This is used only if {@link $security} is enabled. One directory per array element. {@link $template_dir} is in this list implicitly.
Smarty::$security property This enables template security. When enabled, many things are restricted in the templates that normally would go unchecked. This is useful when untrusted parties are editing templates and you want a reasonable level of security. (no direct execution…
Smarty::$security_settings property These are the security settings for Smarty. They are used only when {@link $security} is enabled.
Smarty::$template_dir property The name of the directory where templates are located.
Smarty::$trusted_dir property This is an array of directories where trusted php scripts reside. {@link $security} is disabled during their inclusion/execution.
Smarty::$use_sub_dirs property This tells Smarty whether or not to use sub dirs in the cache/ and templates_c/ directories. sub directories better organized, but may not work well with PHP safe mode enabled.
Smarty::$_cache_including property indicate if the current code is used in a compiled include
Smarty::$_cache_info property info that makes up a cache file
Smarty::$_cache_serials property cache serials
Smarty::$_compile_id property for different compiled templates
Smarty::$_config property loaded configuration settings
Smarty::$_conf_obj property configuration object
Smarty::$_dir_perms property default dir permissions
Smarty::$_file_perms property default file permissions
Smarty::$_foreach property keeps track of foreach blocks
Smarty::$_inclusion_depth property current template inclusion depth
Smarty::$_plugins property table keeping track of plugins
Smarty::$_reg_objects property registered objects
Smarty::$_sections property keeps track of sections
Smarty::$_smarty_debug_id property text in URL to enable debug mode
Smarty::$_smarty_debug_info property debugging information for debug console
Smarty::$_smarty_md5 property md5 checksum of the string 'Smarty'
Smarty::$_smarty_vars property stores run-time $smarty.* vars
Smarty::$_tag_stack property keeps track of tag hierarchy
Smarty::$_tpl_vars property where assigned template vars are kept
Smarty::$_version property Smarty version number
Smarty::append function appends values to template variables
Smarty::append_by_ref function appends values to template variables by reference
Smarty::assign function assigns values to template variables
Smarty::assign_by_ref function assigns values to template variables by reference
Smarty::clear_all_assign function clear all the assigned template variables.
Smarty::clear_all_cache function clear the entire contents of cache (all templates)
Smarty::clear_assign function clear the given assigned template variable.
Smarty::clear_cache function clear cached content for the given template and cache id
Smarty::clear_compiled_tpl function clears compiled version of specified template resource, or all compiled template files if one is not specified. This function is for advanced use only, not normally needed.
Smarty::clear_config function clear configuration values
Smarty::config_load function load configuration values
Smarty::display function executes & displays the template results
Smarty::fetch function executes & returns or displays the template results
Smarty::get_config_vars function Returns an array containing config variables
Smarty::get_registered_object function return a reference to a registered object
Smarty::get_template_vars function Returns an array containing template variables
Smarty::is_cached function test to see if valid cache exists for this template
Smarty::load_filter function load a filter of specified type and name
Smarty::register_block function Registers block function to be used in templates
Smarty::register_compiler_function function Registers compiler function
Smarty::register_function function Registers custom function to be used in templates
Smarty::register_modifier function Registers modifier to be used in templates
Smarty::register_object function Registers object to be used in templates
Smarty::register_outputfilter function Registers an output filter function to apply to a template output
Smarty::register_postfilter function Registers a postfilter function to apply to a compiled template after compilation
Smarty::register_prefilter function Registers a prefilter function to apply to a template before compiling
Smarty::register_resource function Registers a resource to fetch a template
Smarty::Smarty function The class constructor.
Smarty::template_exists function Checks whether requested template exists.
Smarty::trigger_error function trigger Smarty error
Smarty::unregister_block function Unregisters block function
Smarty::unregister_compiler_function function Unregisters compiler function
Smarty::unregister_function function Unregisters custom function
Smarty::unregister_modifier function Unregisters modifier
Smarty::unregister_object function Unregisters object
Smarty::unregister_outputfilter function Unregisters an outputfilter function
Smarty::unregister_postfilter function Unregisters a postfilter function
Smarty::unregister_prefilter function Unregisters a prefilter function
Smarty::unregister_resource function Unregisters a resource
Smarty::_compile_resource function compile the template
Smarty::_compile_source function compile the given source
Smarty::_dequote function Remove starting and ending quotes from the string
Smarty::_eval function wrapper for eval() retaining $this
Smarty::_fetch_resource_info function fetch the template info. Gets timestamp, and source if get_source is true
Smarty::_get_auto_filename function get a concrete filename for automagically created content
Smarty::_get_auto_id function returns an auto_id for auto-file-functions
Smarty::_get_compile_path function Get the compile path for this resource
Smarty::_get_plugin_filepath function get filepath of requested plugin
Smarty::_include function wrapper for include() retaining $this
Smarty::_is_compiled function test if resource needs compiling
Smarty::_parse_resource_name function parse out the type and name from the resource
Smarty::_process_compiled_include_callback function callback function for preg_replace, to call a non-cacheable block
Smarty::_read_file function read in a file
Smarty::_run_mod_handler function Handle modifiers
Smarty::_smarty_cache_attrs function get or set an array of cached attributes for function that is not cacheable
Smarty::_smarty_include function
Smarty::_trigger_fatal_error function trigger Smarty plugin error
Smarty::_unlink function unlink a file, possibly using expiration time
Smarty_Compiler::$_additional_newline property
Smarty_Compiler::$_avar_regexp property
Smarty_Compiler::$_cacheable_state property
Smarty_Compiler::$_cache_attrs_count property
Smarty_Compiler::$_cache_include property name of optional cache include file Overrides Smarty::$_cache_include
Smarty_Compiler::$_cache_serial property
Smarty_Compiler::$_capture_stack property
Smarty_Compiler::$_current_file property
Smarty_Compiler::$_current_line_no property
Smarty_Compiler::$_cvar_regexp property
Smarty_Compiler::$_db_qstr_regexp property
Smarty_Compiler::$_dvar_guts_regexp property
Smarty_Compiler::$_dvar_regexp property
Smarty_Compiler::$_folded_blocks property
Smarty_Compiler::$_func_call_regexp property
Smarty_Compiler::$_func_regexp property
Smarty_Compiler::$_init_smarty_vars property
Smarty_Compiler::$_mod_regexp property
Smarty_Compiler::$_nocache_count property
Smarty_Compiler::$_num_const_regexp property
Smarty_Compiler::$_obj_call_regexp property
Smarty_Compiler::$_obj_ext_regexp property
Smarty_Compiler::$_obj_params_regexp property
Smarty_Compiler::$_obj_start_regexp property
Smarty_Compiler::$_parenth_param_regexp property
Smarty_Compiler::$_permitted_tokens property
Smarty_Compiler::$_plugin_info property
Smarty_Compiler::$_qstr_regexp property
Smarty_Compiler::$_reg_obj_regexp property
Smarty_Compiler::$_si_qstr_regexp property
Smarty_Compiler::$_strip_depth property
Smarty_Compiler::$_svar_regexp property
Smarty_Compiler::$_var_bracket_regexp property
Smarty_Compiler::$_var_regexp property
Smarty_Compiler::Smarty_Compiler function The class constructor.
Smarty_Compiler::_add_plugin function add plugin
Smarty_Compiler::_compile_arg_list function
Smarty_Compiler::_compile_block_tag function compile block function tag
Smarty_Compiler::_compile_capture_tag function Compile {capture} .. {/capture} tags
Smarty_Compiler::_compile_compiler_tag function compile the custom compiler tag
Smarty_Compiler::_compile_custom_tag function compile custom function tag
Smarty_Compiler::_compile_file function compile a resource
Smarty_Compiler::_compile_foreach_start function Compile {foreach ...} tag.
Smarty_Compiler::_compile_if_tag function Compile {if ...} tag
Smarty_Compiler::_compile_include_php_tag function Compile {include ...} tag
Smarty_Compiler::_compile_include_tag function Compile {include ...} tag
Smarty_Compiler::_compile_insert_tag function Compile {insert ...} tag
Smarty_Compiler::_compile_plugin_call function compiles call to plugin of type $type with name $name returns a string containing the function-name or method call without the paramter-list that would have follow to make the call valid php-syntax
Smarty_Compiler::_compile_registered_object_tag function compile a registered object tag
Smarty_Compiler::_compile_section_start function Compile {section ...} tag
Smarty_Compiler::_compile_smarty_ref function Compiles references of type $smarty.foo
Smarty_Compiler::_compile_tag function Compile a template tag
Smarty_Compiler::_expand_quoted_text function expand quoted text with embedded variables
Smarty_Compiler::_load_filters function load pre- and post-filters
Smarty_Compiler::_parse_attrs function Parse attribute string
Smarty_Compiler::_parse_conf_var function parse configuration variable expression into PHP code
Smarty_Compiler::_parse_is_expr function Parse is expression
Smarty_Compiler::_parse_modifiers function parse modifier chain into PHP code
Smarty_Compiler::_parse_parenth_args function parse arguments in function call parenthesis
Smarty_Compiler::_parse_section_prop function parse section property expression into PHP code
Smarty_Compiler::_parse_var function parse variable expression into PHP code
Smarty_Compiler::_parse_vars_props function compile multiple variables and section properties tokens into PHP code
Smarty_Compiler::_parse_var_props function compile single variable and section properties token into PHP code
Smarty_Compiler::_pop_cacheable_state function check if the compilation changes from non-cacheable to cacheable state with the end of the current plugin return php-code to reflect the transition.
Smarty_Compiler::_pop_tag function pop closing tag-name raise an error if this stack-top doesn't match with the closing tag
Smarty_Compiler::_push_cacheable_state function check if the compilation changes from cacheable to non-cacheable state with the beginning of the current plugin. return php-code to reflect the transition.
Smarty_Compiler::_push_tag function push opening tag-name, file-name and line-number on the tag-stack
Smarty_Compiler::_quote_replace function Quote subpattern references
Smarty_Compiler::_syntax_error function display Smarty syntax error