smarty/libs/sysplugins/internal.templatecompilerbase.php

<?php
/**
* Smarty Internal Plugin Smarty Template Compiler Base
* 
* This file contains the basic classes and methodes for compiling Smarty templates with lexer/parser
* 
* @package Smarty
* @subpackage Compiler
* @author Uwe Tews 
*/
/**
* Main compiler class
*/
class Smarty_Internal_TemplateCompilerBase extends Smarty_Internal_Base {
    // compile tag objects
    static $_tag_objects = array(); 
    // tag stack
    public $_tag_stack = array(); 
    // current template
    public $template = null;

    /**
    * Initialize compiler
    */
    public function __construct()
    {
        parent::__construct(); 
        // get required plugins
        if (!is_object($this->smarty->filter_handler) && (isset($this->smarty->autoload_filters['pre']) || isset($this->smarty->registered_filters['pre']) || isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post']))) {
            $this->smarty->loadPlugin('Smarty_Internal_Run_Filter');
            $this->smarty->filter_handler = new Smarty_Internal_Run_Filter;
        } 
    } 
    // abstract function doCompile($_content);
    /**
    * Methode to compile a Smarty template
    * 
    * @param  $template template object to compile
    * @return bool true if compiling succeeded, false if it failed
    */
    public function compileTemplate($template)
    {
        /* here is where the compiling takes place. Smarty
       tags in the templates are replaces with PHP code,
       then written to compiled files. */
        if (!is_object($template->cacher_object)) {
            $this->smarty->loadPlugin($template->cacher_class);
            $template->cacher_object = new $template->cacher_class;
        } 
        // flag for nochache sections
        $this->nocache = false;
        $this->tag_nocache = false; 
        // assume successfull compiling
        $this->compile_error = false; 
        // save template object in compiler class
        $this->template = $template; 
        // template header code
        $template_header = '';
        if (!$template->suppressHeader) {
            $template_header = "<?php /* Smarty version " . Smarty::$_version . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . "\n";
            $template_header .= "         compiled from \"" . $this->template->getTemplateFilepath() . "\" */ ?>\n";
        } 

        do {
            // flag for aborting current and start recompile
            $this->abort_and_recompile = false; 
            // get template source
            $_content = $template->getTemplateSource(); 
            // run prefilter if required
            if (isset($this->smarty->autoload_filters['pre']) || isset($this->smarty->registered_filters['pre'])) {
                $_content = $this->smarty->filter_handler->execute('pre', $_content);
            } 
            // on empty template just return header
            if ($_content == '') {
                $template->compiled_template = $template_header;
                return true;
            } 
            // init cacher plugin
            $template->cacher_object->initCacher($this); 
            // call compiler
            $_compiled_code = $this->doCompile($_content);
        } while ($this->abort_and_recompile);

        if (!$this->compile_error) {
            // close cacher and return compiled template
            $template->compiled_template = $template_header . $template->cacher_object->closeCacher($this, $_compiled_code); 
            // run postfilter if required
            if (isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) {
                $template->compiled_template = $this->smarty->filter_handler->execute('post', $template->compiled_template);
            } 
            return true;
        } else {
            // compilation error
            return false;
        } 
    } 

    /**
    * Compile Tag
    * 
    *                                              This is a call back from the lexer/parser
    *                                              It executes the required compile plugin for the Smarty tag
    * 
    * @param string $tag tag name
    * @param array $args array with tag attributes
    * @return string compiled code
    */
    public function compileTag($tag, $args)
    { 
        // $args contains the attributes parsed and compiled by the lexer/parser
        // assume that tag does compile into code, but creates no HTML output
        $this->has_code = true;
        $this->has_output = false; 
        // compile the smarty tag (required compile classes to compile the tag are autoloaded)
        if (($_output = $this->$tag($args, $this)) === false) {
            if (isset($this->smarty->template_functions[$tag])) {
                // template defined by {template} tag
                $args['name'] = $tag;
                $tag = 'internal_function_call';
                $_output = $this->$tag($args, $this);
            } 
        } 
        if ($_output !== false) {
            if ($_output !== true) {
                // did we get compiled code
                if ($this->has_code) {
                    // Does it create output?
                    if ($this->has_output) {
                        $_output .= "\n";
                    } 
                    // return compiled code
                    return $_output;
                } 
            } 
            // tag did not produce compiled code
            return '';
        } else {
            // not an internal compiler tag
            // check if tag is a registered object
            if (isset($this->smarty->registered_objects[$tag]) && isset($args['object_methode'])) {
                $methode = $args['object_methode'];
                unset ($args['object_methode']);
                if (!in_array($methode, $this->smarty->registered_objects[$tag][3]) &&
                        (empty($this->smarty->registered_objects[$tag][1]) || in_array($methode, $this->smarty->registered_objects[$tag][1]))) {
                    return $this->object_function($args, $tag, $methode, $this);
                } elseif (in_array($methode, $this->smarty->registered_objects[$tag][3])) {
                    return $this->object_block_function($args, $tag, $methode, $this);
                } else {
                    return $this->trigger_template_error ('unallowed methode "' . $methode . '" in registered object "' . $tag . '"');
                } 
            } 
            // check if tag is registered or is Smarty plugin
            $this->smarty->plugin_handler->loadSmartyPlugin($tag, $this->smarty->plugin_search_order);
            if (isset($this->smarty->registered_plugins[$tag])) {
                // check no cache
                if (!$this->smarty->registered_plugins[$tag][2]) {
                    $this->tag_nocache = true;
                } 
                // if compiler function plugin call it now
                if ($this->smarty->registered_plugins[$tag][0] == 'compiler') {
                    $this->tag_nocache = false;
                    return call_user_func_array($this->smarty->registered_plugins[$tag][1], array($args, $this));
                } 
                // compile function or block plugin
                $plugin_type = $this->smarty->registered_plugins[$tag][0] . '_plugin';
                return $this->$plugin_type($args, $tag, $this);
            } 
            // compile closing tag of block function
            if (strlen($tag) > 5 && substr_compare($tag, 'close', -5, 5) == 0) {
                $base_tag = substr($tag, 0, -5); 
                // check if closing tag is a registered object
                if (isset($this->smarty->registered_objects[$base_tag]) && isset($args['object_methode'])) {
                    $methode = $args['object_methode'];
                    unset ($args['object_methode']);
                    if (in_array($methode, $this->smarty->registered_objects[$base_tag][3])) {
                        return $this->object_block_function($args, $tag, $methode, $this);
                    } else {
                        return $this->trigger_template_error ('unallowed closing tag methode "' . $methode . '" in registered object "' . $base_tag . '"');
                    } 
                } 
                // plugin ?
                if (isset($this->smarty->registered_plugins[$base_tag]) && $this->smarty->registered_plugins[$base_tag][0] == 'block') {
                    // check no cache
                    if (!$this->smarty->registered_plugins[$base_tag][2]) {
                        $this->tag_nocache = true;
                    } 
                    return $this->block_plugin($args, $tag, $this);
                } 
            } 
            $this->trigger_template_error ("unknown tag \"" . $tag . "\"");
        } 
    } 

    /**
    * lazy loads internal compile plugin for tag and calls the compile methode
    * 
    * compile objects cached for reuse.
    * class name format:  Smarty_Internal_Compile_TagName
    * plugin filename format: internal.compile_tagname.php
    * 
    * @param  $tag string tag name
    * @param  $args array with tag attributes
    * @return string compiled code
    */
    public function __call($name, $args)
    { 
        // re-use object if already exists
        if (isset(self::$_tag_objects[$name])) {
            // compile this tag
            return call_user_func_array(array(self::$_tag_objects[$name], 'compile'), $args);
        } 
        // lazy load internal compiler plugin
        $class_name = "Smarty_Internal_Compile_{$name}";
        if ($this->smarty->loadPlugin($class_name)) {
            // use plugin if found
            self::$_tag_objects[$name] = new $class_name; 
            // compile this tag
            return call_user_func_array(array(self::$_tag_objects[$name], 'compile'), $args);
        } 
        // no internal compile plugin for this tag
        return false;
    } 

    /**
    * display compiler error messages without dying
    * 
    * If parameter $args is empty it is a parser detected syntax error.
    * In this case the parser is called to obtain information about expected tokens.
    * 
    * If parameter $args contains a string this is used as error message
    * 
    * @todo output exact position of parse error in source line
    * @param  $args string individual error message or null
    */
    public function trigger_template_error($args = null)
    {
        $this->lex = Smarty_Internal_Templatelexer::instance();
        $this->parser = Smarty_Internal_Templateparser::instance(); 
        // get template source line which has error
        $line = $this->lex->line;
        if (isset($args)) {
            // $line--;
        } 
        $match = preg_split("/\n/", $this->lex->data);
        $error_text = 'Syntax Error in template "' . $this->template->getTemplateFilepath() . '"  on line ' . $line . ' "' . $match[$line-1] . '" ';

        if (isset($args)) {
            // individual error message
            $error_text .= $args;
        } else {
            // expected token from parser
            foreach ($this->parser->yy_get_expected_tokens($this->parser->yymajor) as $token) {
                $exp_token = $this->parser->yyTokenName[$token];
                if (isset($this->lex->smarty_token_names[$exp_token])) {
                    // token type from lexer
                    $expect[] = '"' . $this->lex->smarty_token_names[$exp_token] . '"';
                } else {
                    // otherwise internal token name
                    $expect[] = $this->parser->yyTokenName[$token];
                } 
            } 
            // output parser error message
            $error_text .= ' - Unexpected "' . $this->lex->value . '", expected one of: ' . implode(' , ', $expect);
        } 
        throw new Exception($error_text); 
        // set error flag
        $this->compile_error = true;
    } 
} 

?>