Хранилища Subversion ant

<?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 {
    // compile tag objects
    static $_tag_objects = array();
    // tag stack
    public $_tag_stack = array();
    // current template
    public $template = null;

    /**
    * Initialize compiler
    */
    public function __construct()
    {
    }
    // 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($this->smarty);
        }
        // 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->createPropertyHeader() . $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->createPropertyHeader() . $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])) {
                // if compiler function plugin call it now
                if ($this->smarty->registered_plugins[$tag][0] == 'compiler') {
                    if (!$this->smarty->registered_plugins[$tag][2]) {
                        $this->tag_nocache = true;
                    }
                    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') {
                    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;
    }
}

?>