<?php

/**

 * Smarty Internal Plugin Smarty Template Compiler Base

 * This file contains the basic classes and methods for compiling Smarty templates with lexer/parser

 *

 * @package    Smarty

 * @subpackage Compiler

 * @author     Uwe Tews

 */

/**

 * Main abstract compiler class

 *

 * @package    Smarty

 * @subpackage Compiler

 */

abstract class Smarty_Internal_TemplateCompilerBase {

    /**

     * Smarty object

     *

     * @var Smarty

     */

    public $smarty = null;

    /**

     * hash for nocache sections

     *

     * @var mixed

     */

    public $nocache_hash = null;

    /**

     * suppress generation of nocache code

     *

     * @var bool

     */

    public $suppressNocacheProcessing = false;

    /**

     * compile tag objects

     *

     * @var array

     */

    public static $_tag_objects = array();

    /**

     * tag stack

     *

     * @var array

     */

    public $_tag_stack = array();

    /**

     * current template

     *

     * @var Smarty_Internal_Template

     */

    public $template = null;

    /**

     * merged included sub template data

     *

     * @var array

     */

    public $mergedSubTemplatesData = array();

    /**

     * merged sub template code

     *

     * @var array

     */

    public $mergedSubTemplatesCode = array();

    /**

     * collected template properties during compilation

     *

     * @var array

     */

    public $templateProperties = array();

    /**

     * sources which must be compiled

     *

     * @var array

     */

    public $sources = array();

    /**

     * flag that we are inside {block}

     *

     * @var bool

     */

    public $inheritance = false;

    /**

     * flag when compiling inheritance child template

     *

     * @var bool

     */

    public $inheritance_child = false;

    /**

     * uid of templates called by {extends} for recursion check

     *

     * @var array

     */

    public $extends_uid = array();

    /**

     * source line offset for error messages

     *

     * @var int

     */

    public $trace_line_offset = 0;

    /**

     * trace uid

     *

     * @var string

     */

    public $trace_uid = '';

    /**

     * trace file path

     *

     * @var string

     */

    public $trace_filepath = '';

    /**

     * stack for tracing file and line of nested {block} tags

     *

     * @var array

     */

    public $trace_stack = array();

    /**

     * plugins loaded by default plugin handler

     *

     * @var array

     */

    public $default_handler_plugins = array();

    /**

     * saved preprocessed modifier list

     *

     * @var mixed

     */

    public $default_modifier_list = null;

    /**

     * force compilation of complete template as nocache

     *

     * @var boolean

     */

    public $forceNocache = false;

    /**

     * suppress Smarty header code in compiled template

     *

     * @var bool

     */

    public $suppressHeader = false;

    /**

     * suppress template property header code in compiled template

     *

     * @var bool

     */

    public $suppressTemplatePropertyHeader = false;

    /**

     * suppress pre and post filter

     *

     * @var bool

     */

    public $suppressFilter = false;

    /**

     * flag if compiled template file shall we written

     *

     * @var bool

     */

    public $write_compiled_code = true;

    /**

     * flag if currently a template function is compiled

     *

     * @var bool

     */

    public $compiles_template_function = false;

    /**

     * called sub functions from template function

     *

     * @var array

     */

    public $called_functions = array();

    /**

     * compiled template function code

     *

     * @var string

     */

    public $templateFunctionCode = '';

    /**

     * php_handling setting either from Smarty or security

     *

     * @var int

     */

    public $php_handling = 0;

    /**

     * flags for used modifier plugins

     *

     * @var array

     */

    public $modifier_plugins = array();

    /**

     * type of already compiled modifier

     *

     * @var array

     */

    public $known_modifier_type = array();

    /**

     * parent compiler object for merged subtemplates and template functions

     *

     * @var Smarty_Internal_TemplateCompilerBase

     */

    public $parent_compiler = null;

    /**

     * Flag true when compiling nocache section

     *

     * @var bool

     */

    public $nocache = false;

    /**

     * Flag true when tag is compiled as nocache

     *

     * @var bool

     */

    public $tag_nocache = false;

    /**

     * Flag to restart parsing

     *

     * @var bool

     */

    public $abort_and_recompile = false;

    /**

     * Compiled tag prefix code

     *

     * @var array

     */

    public $prefix_code = array();

    /**

     * Prefix code  stack

     *

     * @var array

     */

    public $prefixCodeStack = array();

    /**

     * Tag has compiled code

     *

     * @var bool

     */

    public $has_code = false;

    /**

     * A variable string was compiled

     *

     * @var bool

     */

    public $has_variable_string = false;

    /**

     * Tag creates output

     *

     * @var bool

     */

    public $has_output = false;

    /**

     * Strip preg pattern

     *

     * @var string

     */

    public $stripRegEx = '![\t ]*[\r\n]+[\t ]*!';

    /**

     * method to compile a Smarty template

     *

     * @param  mixed $_content template source

     *

     * @return bool  true if compiling succeeded, false if it failed

     */

    abstract protected function doCompile($_content);

    /**

     * Initialize compiler

     */

    public function __construct() {

        $this->nocache_hash = str_replace(array('.', ','), '_', uniqid(rand(), true));

    }

    /**

     * Method to compile a Smarty template

     *

     * @param  Smarty_Internal_Template $template template object to compile

     * @param  bool $nocache true is shall be compiled in nocache mode

     * @param null|Smarty_Internal_TemplateCompilerBase $parent_compiler

     *

     * @return bool true if compiling succeeded, false if it failed

     */

    public function compileTemplate(Smarty_Internal_Template $template, $nocache = null, $parent_compiler = null) {

        // save template object in compiler class

        $this->template = $template;

        if (isset($this->template->smarty->security_policy)) {

            $this->php_handling = $this->template->smarty->security_policy->php_handling;

        } else {

            $this->php_handling = $this->template->smarty->php_handling;

        }

        $this->parent_compiler = $parent_compiler ? $parent_compiler : $this;

        $nocache = isset($nocache) ? $nocache : false;

        if (empty($template->properties['nocache_hash'])) {

            $template->properties['nocache_hash'] = $this->nocache_hash;

        } else {

            $this->nocache_hash = $template->properties['nocache_hash'];

        }

        $save_source = $this->template->source;

        // template header code

        $template_header = '';

        if (!$this->suppressHeader) {

            $template_header .= "<?php /* Smarty version " . Smarty::SMARTY_VERSION . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . "\n";

            $template_header .= "         compiled from \"" . $this->template->source->filepath . "\" */ ?>\n";

        }

        if (empty($this->template->source->components)) {

            $this->sources = array($template->source);

        } else {

            // we have array of inheritance templates by extends: resource

            $this->sources = array_reverse($template->source->components);

        }

        $loop = 0;

        // the $this->sources array can get additional elements while compiling by the {extends} tag

        while ($this->template->source = array_shift($this->sources)) {

            $this->smarty->_current_file = $this->template->source->filepath;

            if ($this->smarty->debugging) {

                Smarty_Internal_Debug::start_compile($this->template);

            }

            $no_sources = count($this->sources);

            $this->parent_compiler->template->properties['file_dependency'][$this->template->source->uid] = array($this->template->source->filepath, $this->template->source->timestamp, $this->template->source->type);

            $loop++;

            if ($no_sources) {

                $this->inheritance_child = true;

            } else {

                $this->inheritance_child = false;

            }

            do {

                // flag for nochache sections

                $this->nocache = $nocache;

                $this->tag_nocache = false;

                // reset has nocache code flag

                $this->template->has_nocache_code = false;

                $this->has_variable_string = false;

                $this->prefix_code = array();

                $_compiled_code = '';

                // flag for aborting current and start recompile

                $this->abort_and_recompile = false;

                // get template source

                $_content = $this->template->source->content;

                if ($_content != '') {

                    // run prefilter if required

                    if ((isset($this->smarty->autoload_filters['pre']) || isset($this->smarty->registered_filters['pre'])) && !$this->suppressFilter) {

                        $_content = Smarty_Internal_Filter_Handler::runFilter('pre', $_content, $template);

                    }

                    // call compiler

                    $_compiled_code = $this->doCompile($_content, true);

                }

            } while ($this->abort_and_recompile);

            if ($this->smarty->debugging) {

                Smarty_Internal_Debug::end_compile($this->template);

            }

        }

        // restore source

        $this->template->source = $save_source;

        unset($save_source);

        $this->smarty->_current_file = $this->template->source->filepath;

        // free memory

        unset($this->parser->root_buffer, $this->parser->current_buffer, $this->parser, $this->lex);

        self::$_tag_objects = array();

        // return compiled code to template object

        $merged_code = '';

        if (!empty($this->mergedSubTemplatesCode)) {

            foreach ($this->mergedSubTemplatesCode as $code) {

                $merged_code .= $code;

            }

        }

        // run postfilter if required on compiled template code

        if ((isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) && !$this->suppressFilter && $_compiled_code != '') {

            $_compiled_code = Smarty_Internal_Filter_Handler::runFilter('post', $_compiled_code, $template);

        }

        if ($this->suppressTemplatePropertyHeader) {

            $_compiled_code .= $merged_code;

        } else {

            $_compiled_code = $template_header . Smarty_Internal_Extension_CodeFrame::create($template, $_compiled_code) . $merged_code;

        }

        if (!empty($this->templateFunctionCode)) {

            // run postfilter if required on compiled template code

            if ((isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) && !$this->suppressFilter) {

                $_compiled_code .= Smarty_Internal_Filter_Handler::runFilter('post', $this->templateFunctionCode, $template);

            } else {

                $_compiled_code .= $this->templateFunctionCode;

            }

        }

        // unset content because template inheritance could have replace source with parent code

        unset ($template->source->content);

        $this->parent_compiler = null;

        $this->template = null;

        return $_compiled_code;

    }

    /**

     * Compile Tag

     * This is a call back from the lexer/parser

     *

     * Save current prefix code

     * Compile tag

     * Merge tag prefix code with saved one

     * (required nested tags in attributes)

     *

     * @param  string $tag tag name

     * @param  array $args array with tag attributes

     * @param  array $parameter array with compilation parameter

     *

     * @throws SmartyCompilerException

     * @throws SmartyException

     * @return string compiled code

     */

    public function compileTag($tag, $args, $parameter = array()) {

        $this->prefixCodeStack[] = $this->prefix_code;

        $this->prefix_code = array();

        $result = $this->compileTag2($tag, $args, $parameter);

        $this->prefix_code = array_merge($this->prefix_code, array_pop($this->prefixCodeStack));

        return $result;

    }

    /**

     * Compile Tag

     *

     * @param  string $tag tag name

     * @param  array $args array with tag attributes

     * @param  array $parameter array with compilation parameter

     *

     * @throws SmartyCompilerException

     * @throws SmartyException

     * @return string compiled code

     */

    private function compileTag2($tag, $args, $parameter) {

        $plugin_type = '';

        // $args contains the attributes parsed and compiled by the lexer/parser

        // assume that tag does compile into code, but creates no HTML output

        $this->has_code = true;

        $this->has_output = false;

        // log tag/attributes

        if (isset($this->smarty->get_used_tags) && $this->smarty->get_used_tags) {

            $this->template->used_tags[] = array($tag, $args);

        }

        // check nocache option flag

        if (in_array("'nocache'", $args) || in_array(array('nocache' => 'true'), $args) || in_array(array('nocache' => '"true"'), $args) || in_array(array('nocache' => "'true'"), $args)

        ) {

            $this->tag_nocache = true;

        }

        // compile the smarty tag (required compile classes to compile the tag are autoloaded)

        if (($_output = $this->callTagCompiler($tag, $args, $parameter)) === false) {

            if (isset($this->parent_compiler->templateProperties['tpl_function'][$tag])) {

                // template defined by {template} tag

                $args['_attr']['name'] = "'" . $tag . "'";

                $_output = $this->callTagCompiler('call', $args, $parameter);

            }

        }

        if ($_output !== false) {

            if ($_output !== true) {

                // did we get compiled code

                if ($this->has_code) {

                    // Does it create output?

                    if ($this->has_output) {

                        $_output .= "\n";

                    }

                    // return compiled code

                    return $_output;

                }

            }

            // tag did not produce compiled code

            return null;

        } else {

            // map_named attributes

            if (isset($args['_attr'])) {

                foreach ($args['_attr'] as $key => $attribute) {

                    if (is_array($attribute)) {

                        $args = array_merge($args, $attribute);

                    }

                }

            }

            // not an internal compiler tag

            if (strlen($tag) < 6 || substr($tag, -5) != 'close') {

                // check if tag is a registered object

                if (isset($this->smarty->registered_objects[$tag]) && isset($parameter['object_method'])) {

                    $method = $parameter['object_method'];

                    if (!in_array($method, $this->smarty->registered_objects[$tag][3]) && (empty($this->smarty->registered_objects[$tag][1]) || in_array($method, $this->smarty->registered_objects[$tag][1]))

                    ) {

                        return $this->callTagCompiler('private_object_function', $args, $parameter, $tag, $method);

                    } elseif (in_array($method, $this->smarty->registered_objects[$tag][3])) {

                        return $this->callTagCompiler('private_object_block_function', $args, $parameter, $tag, $method);

                    } else {

                        // throw exception

                        $this->trigger_template_error('not allowed method "' . $method . '" in registered object "' . $tag . '"', $this->lex->taglineno);

                    }

                }