library/smarty/libs/sysplugins/smarty_internal_templatecompilerbase.php
changeset 0 4869aea77e21
equal deleted inserted replaced
-1:000000000000 0:4869aea77e21
       
     1 <?php
       
     2 
       
     3 /**
       
     4  * Smarty Internal Plugin Smarty Template Compiler Base
       
     5  * This file contains the basic classes and methods for compiling Smarty templates with lexer/parser
       
     6  *
       
     7  * @package    Smarty
       
     8  * @subpackage Compiler
       
     9  * @author     Uwe Tews
       
    10  */
       
    11 
       
    12 /**
       
    13  * Main abstract compiler class
       
    14  *
       
    15  * @package    Smarty
       
    16  * @subpackage Compiler
       
    17  */
       
    18 abstract class Smarty_Internal_TemplateCompilerBase {
       
    19 
       
    20     /**
       
    21      * Smarty object
       
    22      *
       
    23      * @var Smarty
       
    24      */
       
    25     public $smarty = null;
       
    26 
       
    27     /**
       
    28      * hash for nocache sections
       
    29      *
       
    30      * @var mixed
       
    31      */
       
    32     public $nocache_hash = null;
       
    33 
       
    34     /**
       
    35      * suppress generation of nocache code
       
    36      *
       
    37      * @var bool
       
    38      */
       
    39     public $suppressNocacheProcessing = false;
       
    40 
       
    41     /**
       
    42      * compile tag objects
       
    43      *
       
    44      * @var array
       
    45      */
       
    46     public static $_tag_objects = array();
       
    47 
       
    48     /**
       
    49      * tag stack
       
    50      *
       
    51      * @var array
       
    52      */
       
    53     public $_tag_stack = array();
       
    54 
       
    55     /**
       
    56      * current template
       
    57      *
       
    58      * @var Smarty_Internal_Template
       
    59      */
       
    60     public $template = null;
       
    61 
       
    62     /**
       
    63      * merged included sub template data
       
    64      *
       
    65      * @var array
       
    66      */
       
    67     public $mergedSubTemplatesData = array();
       
    68 
       
    69     /**
       
    70      * merged sub template code
       
    71      *
       
    72      * @var array
       
    73      */
       
    74     public $mergedSubTemplatesCode = array();
       
    75 
       
    76     /**
       
    77      * collected template properties during compilation
       
    78      *
       
    79      * @var array
       
    80      */
       
    81     public $templateProperties = array();
       
    82 
       
    83     /**
       
    84      * sources which must be compiled
       
    85      *
       
    86      * @var array
       
    87      */
       
    88     public $sources = array();
       
    89 
       
    90     /**
       
    91      * flag that we are inside {block}
       
    92      *
       
    93      * @var bool
       
    94      */
       
    95     public $inheritance = false;
       
    96 
       
    97     /**
       
    98      * flag when compiling inheritance child template
       
    99      *
       
   100      * @var bool
       
   101      */
       
   102     public $inheritance_child = false;
       
   103 
       
   104     /**
       
   105      * uid of templates called by {extends} for recursion check
       
   106      *
       
   107      * @var array
       
   108      */
       
   109     public $extends_uid = array();
       
   110 
       
   111     /**
       
   112      * source line offset for error messages
       
   113      *
       
   114      * @var int
       
   115      */
       
   116     public $trace_line_offset = 0;
       
   117 
       
   118     /**
       
   119      * trace uid
       
   120      *
       
   121      * @var string
       
   122      */
       
   123     public $trace_uid = '';
       
   124 
       
   125     /**
       
   126      * trace file path
       
   127      *
       
   128      * @var string
       
   129      */
       
   130     public $trace_filepath = '';
       
   131 
       
   132     /**
       
   133      * stack for tracing file and line of nested {block} tags
       
   134      *
       
   135      * @var array
       
   136      */
       
   137     public $trace_stack = array();
       
   138 
       
   139     /**
       
   140      * plugins loaded by default plugin handler
       
   141      *
       
   142      * @var array
       
   143      */
       
   144     public $default_handler_plugins = array();
       
   145 
       
   146     /**
       
   147      * saved preprocessed modifier list
       
   148      *
       
   149      * @var mixed
       
   150      */
       
   151     public $default_modifier_list = null;
       
   152 
       
   153     /**
       
   154      * force compilation of complete template as nocache
       
   155      *
       
   156      * @var boolean
       
   157      */
       
   158     public $forceNocache = false;
       
   159 
       
   160     /**
       
   161      * suppress Smarty header code in compiled template
       
   162      *
       
   163      * @var bool
       
   164      */
       
   165     public $suppressHeader = false;
       
   166 
       
   167     /**
       
   168      * suppress template property header code in compiled template
       
   169      *
       
   170      * @var bool
       
   171      */
       
   172     public $suppressTemplatePropertyHeader = false;
       
   173 
       
   174     /**
       
   175      * suppress pre and post filter
       
   176      *
       
   177      * @var bool
       
   178      */
       
   179     public $suppressFilter = false;
       
   180 
       
   181     /**
       
   182      * flag if compiled template file shall we written
       
   183      *
       
   184      * @var bool
       
   185      */
       
   186     public $write_compiled_code = true;
       
   187 
       
   188     /**
       
   189      * flag if currently a template function is compiled
       
   190      *
       
   191      * @var bool
       
   192      */
       
   193     public $compiles_template_function = false;
       
   194 
       
   195     /**
       
   196      * called sub functions from template function
       
   197      *
       
   198      * @var array
       
   199      */
       
   200     public $called_functions = array();
       
   201 
       
   202     /**
       
   203      * compiled template function code
       
   204      *
       
   205      * @var string
       
   206      */
       
   207     public $templateFunctionCode = '';
       
   208 
       
   209     /**
       
   210      * php_handling setting either from Smarty or security
       
   211      *
       
   212      * @var int
       
   213      */
       
   214     public $php_handling = 0;
       
   215 
       
   216     /**
       
   217      * flags for used modifier plugins
       
   218      *
       
   219      * @var array
       
   220      */
       
   221     public $modifier_plugins = array();
       
   222 
       
   223     /**
       
   224      * type of already compiled modifier
       
   225      *
       
   226      * @var array
       
   227      */
       
   228     public $known_modifier_type = array();
       
   229 
       
   230     /**
       
   231      * parent compiler object for merged subtemplates and template functions
       
   232      *
       
   233      * @var Smarty_Internal_TemplateCompilerBase
       
   234      */
       
   235     public $parent_compiler = null;
       
   236 
       
   237     /**
       
   238      * Flag true when compiling nocache section
       
   239      *
       
   240      * @var bool
       
   241      */
       
   242     public $nocache = false;
       
   243 
       
   244     /**
       
   245      * Flag true when tag is compiled as nocache
       
   246      *
       
   247      * @var bool
       
   248      */
       
   249     public $tag_nocache = false;
       
   250 
       
   251     /**
       
   252      * Flag to restart parsing
       
   253      *
       
   254      * @var bool
       
   255      */
       
   256     public $abort_and_recompile = false;
       
   257 
       
   258     /**
       
   259      * Compiled tag prefix code
       
   260      *
       
   261      * @var array
       
   262      */
       
   263     public $prefix_code = array();
       
   264 
       
   265     /**
       
   266      * Prefix code  stack
       
   267      *
       
   268      * @var array
       
   269      */
       
   270     public $prefixCodeStack = array();
       
   271 
       
   272     /**
       
   273      * Tag has compiled code
       
   274      *
       
   275      * @var bool
       
   276      */
       
   277     public $has_code = false;
       
   278 
       
   279     /**
       
   280      * A variable string was compiled
       
   281      *
       
   282      * @var bool
       
   283      */
       
   284     public $has_variable_string = false;
       
   285 
       
   286     /**
       
   287      * Tag creates output
       
   288      *
       
   289      * @var bool
       
   290      */
       
   291     public $has_output = false;
       
   292 
       
   293     /**
       
   294      * Strip preg pattern
       
   295      *
       
   296      * @var string
       
   297      */
       
   298     public $stripRegEx = '![\t ]*[\r\n]+[\t ]*!';
       
   299 
       
   300     /**
       
   301      * method to compile a Smarty template
       
   302      *
       
   303      * @param  mixed $_content template source
       
   304      *
       
   305      * @return bool  true if compiling succeeded, false if it failed
       
   306      */
       
   307     abstract protected function doCompile($_content);
       
   308 
       
   309     /**
       
   310      * Initialize compiler
       
   311      */
       
   312     public function __construct() {
       
   313         $this->nocache_hash = str_replace(array('.', ','), '_', uniqid(rand(), true));
       
   314     }
       
   315 
       
   316     /**
       
   317      * Method to compile a Smarty template
       
   318      *
       
   319      * @param  Smarty_Internal_Template $template template object to compile
       
   320      * @param  bool $nocache true is shall be compiled in nocache mode
       
   321      * @param null|Smarty_Internal_TemplateCompilerBase $parent_compiler
       
   322      *
       
   323      * @return bool true if compiling succeeded, false if it failed
       
   324      */
       
   325     public function compileTemplate(Smarty_Internal_Template $template, $nocache = null, $parent_compiler = null) {
       
   326         // save template object in compiler class
       
   327         $this->template = $template;
       
   328         if (isset($this->template->smarty->security_policy)) {
       
   329             $this->php_handling = $this->template->smarty->security_policy->php_handling;
       
   330         } else {
       
   331             $this->php_handling = $this->template->smarty->php_handling;
       
   332         }
       
   333         $this->parent_compiler = $parent_compiler ? $parent_compiler : $this;
       
   334         $nocache = isset($nocache) ? $nocache : false;
       
   335         if (empty($template->properties['nocache_hash'])) {
       
   336             $template->properties['nocache_hash'] = $this->nocache_hash;
       
   337         } else {
       
   338             $this->nocache_hash = $template->properties['nocache_hash'];
       
   339         }
       
   340         $save_source = $this->template->source;
       
   341         // template header code
       
   342         $template_header = '';
       
   343         if (!$this->suppressHeader) {
       
   344             $template_header .= "<?php /* Smarty version " . Smarty::SMARTY_VERSION . ", created on " . strftime("%Y-%m-%d %H:%M:%S") . "\n";
       
   345             $template_header .= "         compiled from \"" . $this->template->source->filepath . "\" */ ?>\n";
       
   346         }
       
   347 
       
   348         if (empty($this->template->source->components)) {
       
   349             $this->sources = array($template->source);
       
   350         } else {
       
   351             // we have array of inheritance templates by extends: resource
       
   352             $this->sources = array_reverse($template->source->components);
       
   353         }
       
   354         $loop = 0;
       
   355         // the $this->sources array can get additional elements while compiling by the {extends} tag
       
   356         while ($this->template->source = array_shift($this->sources)) {
       
   357             $this->smarty->_current_file = $this->template->source->filepath;
       
   358             if ($this->smarty->debugging) {
       
   359                 Smarty_Internal_Debug::start_compile($this->template);
       
   360             }
       
   361             $no_sources = count($this->sources);
       
   362             $this->parent_compiler->template->properties['file_dependency'][$this->template->source->uid] = array($this->template->source->filepath, $this->template->source->timestamp, $this->template->source->type);
       
   363             $loop++;
       
   364             if ($no_sources) {
       
   365                 $this->inheritance_child = true;
       
   366             } else {
       
   367                 $this->inheritance_child = false;
       
   368             }
       
   369             do {
       
   370                 // flag for nochache sections
       
   371                 $this->nocache = $nocache;
       
   372                 $this->tag_nocache = false;
       
   373                 // reset has nocache code flag
       
   374                 $this->template->has_nocache_code = false;
       
   375                 $this->has_variable_string = false;
       
   376                 $this->prefix_code = array();
       
   377                 $_compiled_code = '';
       
   378                 // flag for aborting current and start recompile
       
   379                 $this->abort_and_recompile = false;
       
   380                 // get template source
       
   381                 $_content = $this->template->source->content;
       
   382                 if ($_content != '') {
       
   383                     // run prefilter if required
       
   384                     if ((isset($this->smarty->autoload_filters['pre']) || isset($this->smarty->registered_filters['pre'])) && !$this->suppressFilter) {
       
   385                         $_content = Smarty_Internal_Filter_Handler::runFilter('pre', $_content, $template);
       
   386                     }
       
   387                     // call compiler
       
   388                     $_compiled_code = $this->doCompile($_content, true);
       
   389                 }
       
   390             } while ($this->abort_and_recompile);
       
   391             if ($this->smarty->debugging) {
       
   392                 Smarty_Internal_Debug::end_compile($this->template);
       
   393             }
       
   394         }
       
   395         // restore source
       
   396         $this->template->source = $save_source;
       
   397         unset($save_source);
       
   398         $this->smarty->_current_file = $this->template->source->filepath;
       
   399         // free memory
       
   400         unset($this->parser->root_buffer, $this->parser->current_buffer, $this->parser, $this->lex);
       
   401         self::$_tag_objects = array();
       
   402         // return compiled code to template object
       
   403         $merged_code = '';
       
   404         if (!empty($this->mergedSubTemplatesCode)) {
       
   405             foreach ($this->mergedSubTemplatesCode as $code) {
       
   406                 $merged_code .= $code;
       
   407             }
       
   408         }
       
   409         // run postfilter if required on compiled template code
       
   410         if ((isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) && !$this->suppressFilter && $_compiled_code != '') {
       
   411             $_compiled_code = Smarty_Internal_Filter_Handler::runFilter('post', $_compiled_code, $template);
       
   412         }
       
   413         if ($this->suppressTemplatePropertyHeader) {
       
   414             $_compiled_code .= $merged_code;
       
   415         } else {
       
   416             $_compiled_code = $template_header . Smarty_Internal_Extension_CodeFrame::create($template, $_compiled_code) . $merged_code;
       
   417         }
       
   418         if (!empty($this->templateFunctionCode)) {
       
   419             // run postfilter if required on compiled template code
       
   420             if ((isset($this->smarty->autoload_filters['post']) || isset($this->smarty->registered_filters['post'])) && !$this->suppressFilter) {
       
   421                 $_compiled_code .= Smarty_Internal_Filter_Handler::runFilter('post', $this->templateFunctionCode, $template);
       
   422             } else {
       
   423                 $_compiled_code .= $this->templateFunctionCode;
       
   424             }
       
   425         }
       
   426         // unset content because template inheritance could have replace source with parent code
       
   427         unset ($template->source->content);
       
   428         $this->parent_compiler = null;
       
   429         $this->template = null;
       
   430         return $_compiled_code;
       
   431     }
       
   432 
       
   433     /**
       
   434      * Compile Tag
       
   435      * This is a call back from the lexer/parser
       
   436      *
       
   437      * Save current prefix code
       
   438      * Compile tag
       
   439      * Merge tag prefix code with saved one
       
   440      * (required nested tags in attributes)
       
   441      *
       
   442      * @param  string $tag tag name
       
   443      * @param  array $args array with tag attributes
       
   444      * @param  array $parameter array with compilation parameter
       
   445      *
       
   446      * @throws SmartyCompilerException
       
   447      * @throws SmartyException
       
   448      * @return string compiled code
       
   449      */
       
   450     public function compileTag($tag, $args, $parameter = array()) {
       
   451         $this->prefixCodeStack[] = $this->prefix_code;
       
   452         $this->prefix_code = array();
       
   453         $result = $this->compileTag2($tag, $args, $parameter);
       
   454         $this->prefix_code = array_merge($this->prefix_code, array_pop($this->prefixCodeStack));
       
   455         return $result;
       
   456     }
       
   457 
       
   458     /**
       
   459      * Compile Tag
       
   460      *
       
   461      * @param  string $tag tag name
       
   462      * @param  array $args array with tag attributes
       
   463      * @param  array $parameter array with compilation parameter
       
   464      *
       
   465      * @throws SmartyCompilerException
       
   466      * @throws SmartyException
       
   467      * @return string compiled code
       
   468      */
       
   469     private function compileTag2($tag, $args, $parameter) {
       
   470         $plugin_type = '';
       
   471         // $args contains the attributes parsed and compiled by the lexer/parser
       
   472         // assume that tag does compile into code, but creates no HTML output
       
   473         $this->has_code = true;
       
   474         $this->has_output = false;
       
   475         // log tag/attributes
       
   476         if (isset($this->smarty->get_used_tags) && $this->smarty->get_used_tags) {
       
   477             $this->template->used_tags[] = array($tag, $args);
       
   478         }
       
   479         // check nocache option flag
       
   480         if (in_array("'nocache'", $args) || in_array(array('nocache' => 'true'), $args) || in_array(array('nocache' => '"true"'), $args) || in_array(array('nocache' => "'true'"), $args)
       
   481         ) {
       
   482             $this->tag_nocache = true;
       
   483         }
       
   484         // compile the smarty tag (required compile classes to compile the tag are autoloaded)
       
   485         if (($_output = $this->callTagCompiler($tag, $args, $parameter)) === false) {
       
   486             if (isset($this->parent_compiler->templateProperties['tpl_function'][$tag])) {
       
   487                 // template defined by {template} tag
       
   488                 $args['_attr']['name'] = "'" . $tag . "'";
       
   489                 $_output = $this->callTagCompiler('call', $args, $parameter);
       
   490             }
       
   491         }
       
   492         if ($_output !== false) {
       
   493             if ($_output !== true) {
       
   494                 // did we get compiled code
       
   495                 if ($this->has_code) {
       
   496                     // Does it create output?
       
   497                     if ($this->has_output) {
       
   498                         $_output .= "\n";
       
   499                     }
       
   500                     // return compiled code
       
   501                     return $_output;
       
   502                 }
       
   503             }
       
   504             // tag did not produce compiled code
       
   505             return null;
       
   506         } else {
       
   507             // map_named attributes
       
   508             if (isset($args['_attr'])) {
       
   509                 foreach ($args['_attr'] as $key => $attribute) {
       
   510                     if (is_array($attribute)) {
       
   511                         $args = array_merge($args, $attribute);
       
   512                     }
       
   513                 }
       
   514             }
       
   515             // not an internal compiler tag
       
   516             if (strlen($tag) < 6 || substr($tag, -5) != 'close') {
       
   517                 // check if tag is a registered object
       
   518                 if (isset($this->smarty->registered_objects[$tag]) && isset($parameter['object_method'])) {
       
   519                     $method = $parameter['object_method'];
       
   520                     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]))
       
   521                     ) {
       
   522                         return $this->callTagCompiler('private_object_function', $args, $parameter, $tag, $method);
       
   523                     } elseif (in_array($method, $this->smarty->registered_objects[$tag][3])) {
       
   524                         return $this->callTagCompiler('private_object_block_function', $args, $parameter, $tag, $method);
       
   525                     } else {
       
   526                         // throw exception
       
   527                         $this->trigger_template_error('not allowed method "' . $method . '" in registered object "' . $tag . '"', $this->lex->taglineno);
       
   528                     }
       
   529                 }
       
   530                 // check if tag is registered
       
   531                 foreach (array(Smarty::PLUGIN_COMPILER, Smarty::PLUGIN_FUNCTION, Smarty::PLUGIN_BLOCK) as $plugin_type) {
       
   532                     if (isset($this->smarty->registered_plugins[$plugin_type][$tag])) {
       
   533                         // if compiler function plugin call it now
       
   534                         if ($plugin_type == Smarty::PLUGIN_COMPILER) {
       
   535                             $new_args = array();
       
   536                             foreach ($args as $key => $mixed) {
       
   537                                 if (is_array($mixed)) {
       
   538                                     $new_args = array_merge($new_args, $mixed);
       
   539                                 } else {
       
   540                                     $new_args[$key] = $mixed;
       
   541                                 }
       
   542                             }
       
   543                             if (!$this->smarty->registered_plugins[$plugin_type][$tag][1]) {
       
   544                                 $this->tag_nocache = true;
       
   545                             }
       
   546                             $function = $this->smarty->registered_plugins[$plugin_type][$tag][0];
       
   547                             if (!is_array($function)) {
       
   548                                 return $function($new_args, $this);
       
   549                             } elseif (is_object($function[0])) {
       
   550                                 return $this->smarty->registered_plugins[$plugin_type][$tag][0][0]->$function[1]($new_args, $this);
       
   551                             } else {
       
   552                                 return call_user_func_array($function, array($new_args, $this));
       
   553                             }
       
   554                         }
       
   555                         // compile registered function or block function
       
   556                         if ($plugin_type == Smarty::PLUGIN_FUNCTION || $plugin_type == Smarty::PLUGIN_BLOCK) {
       
   557                             return $this->callTagCompiler('private_registered_' . $plugin_type, $args, $parameter, $tag);
       
   558                         }
       
   559                     }
       
   560                 }
       
   561                 // check plugins from plugins folder
       
   562                 foreach ($this->smarty->plugin_search_order as $plugin_type) {
       
   563                     if ($plugin_type == Smarty::PLUGIN_COMPILER && $this->smarty->loadPlugin('smarty_compiler_' . $tag) && (!isset($this->smarty->security_policy) || $this->smarty->security_policy->isTrustedTag($tag, $this))) {
       
   564                         $plugin = 'smarty_compiler_' . $tag;
       
   565                         if (is_callable($plugin)) {
       
   566                             // convert arguments format for old compiler plugins
       
   567                             $new_args = array();
       
   568                             foreach ($args as $key => $mixed) {
       
   569                                 if (is_array($mixed)) {
       
   570                                     $new_args = array_merge($new_args, $mixed);
       
   571                                 } else {
       
   572                                     $new_args[$key] = $mixed;
       
   573                                 }
       
   574                             }
       
   575 
       
   576                             return $plugin($new_args, $this->smarty);
       
   577                         }
       
   578                         if (class_exists($plugin, false)) {
       
   579                             $plugin_object = new $plugin;
       
   580                             if (method_exists($plugin_object, 'compile')) {
       
   581                                 return $plugin_object->compile($args, $this);
       
   582                             }
       
   583                         }
       
   584                         throw new SmartyException("Plugin \"{$tag}\" not callable");
       
   585                     } else {
       
   586                         if ($function = $this->getPlugin($tag, $plugin_type)) {
       
   587                             if (!isset($this->smarty->security_policy) || $this->smarty->security_policy->isTrustedTag($tag, $this)) {
       
   588                                 return $this->callTagCompiler('private_' . $plugin_type . '_plugin', $args, $parameter, $tag, $function);
       
   589                             }
       
   590                         }
       
   591                     }
       
   592                 }
       
   593                 if (is_callable($this->smarty->default_plugin_handler_func)) {
       
   594                     $found = false;
       
   595                     // look for already resolved tags
       
   596                     foreach ($this->smarty->plugin_search_order as $plugin_type) {
       
   597                         if (isset($this->default_handler_plugins[$plugin_type][$tag])) {
       
   598                             $found = true;
       
   599                             break;
       
   600                         }
       
   601                     }
       
   602                     if (!$found) {
       
   603                         // call default handler
       
   604                         foreach ($this->smarty->plugin_search_order as $plugin_type) {
       
   605                             if ($this->getPluginFromDefaultHandler($tag, $plugin_type)) {
       
   606                                 $found = true;
       
   607                                 break;
       
   608                             }
       
   609                         }
       
   610                     }
       
   611                     if ($found) {
       
   612                         // if compiler function plugin call it now
       
   613                         if ($plugin_type == Smarty::PLUGIN_COMPILER) {
       
   614                             $new_args = array();
       
   615                             foreach ($args as $mixed) {
       
   616                                 $new_args = array_merge($new_args, $mixed);
       
   617                             }
       
   618                             $function = $this->default_handler_plugins[$plugin_type][$tag][0];
       
   619                             if (!is_array($function)) {
       
   620                                 return $function($new_args, $this);
       
   621                             } elseif (is_object($function[0])) {
       
   622                                 return $this->default_handler_plugins[$plugin_type][$tag][0][0]->$function[1]($new_args, $this);
       
   623                             } else {
       
   624                                 return call_user_func_array($function, array($new_args, $this));
       
   625                             }
       
   626                         } else {
       
   627                             return $this->callTagCompiler('private_registered_' . $plugin_type, $args, $parameter, $tag);
       
   628                         }
       
   629                     }
       
   630                 }
       
   631             } else {
       
   632                 // compile closing tag of block function
       
   633                 $base_tag = substr($tag, 0, -5);
       
   634                 // check if closing tag is a registered object
       
   635                 if (isset($this->smarty->registered_objects[$base_tag]) && isset($parameter['object_method'])) {
       
   636                     $method = $parameter['object_method'];
       
   637                     if (in_array($method, $this->smarty->registered_objects[$base_tag][3])) {
       
   638                         return $this->callTagCompiler('private_object_block_function', $args, $parameter, $tag, $method);
       
   639                     } else {
       
   640                         // throw exception
       
   641                         $this->trigger_template_error('not allowed closing tag method "' . $method . '" in registered object "' . $base_tag . '"', $this->lex->taglineno);
       
   642                     }
       
   643                 }
       
   644                 // registered block tag ?
       
   645                 if (isset($this->smarty->registered_plugins[Smarty::PLUGIN_BLOCK][$base_tag]) || isset($this->default_handler_plugins[Smarty::PLUGIN_BLOCK][$base_tag])) {
       
   646                     return $this->callTagCompiler('private_registered_block', $args, $parameter, $tag);
       
   647                 }
       
   648                 // block plugin?
       
   649                 if ($function = $this->getPlugin($base_tag, Smarty::PLUGIN_BLOCK)) {
       
   650                     return $this->callTagCompiler('private_block_plugin', $args, $parameter, $tag, $function);
       
   651                 }
       
   652                 // registered compiler plugin ?
       
   653                 if (isset($this->smarty->registered_plugins[Smarty::PLUGIN_COMPILER][$tag])) {
       
   654                     // if compiler function plugin call it now
       
   655                     $args = array();
       
   656                     if (!$this->smarty->registered_plugins[Smarty::PLUGIN_COMPILER][$tag][1]) {
       
   657                         $this->tag_nocache = true;
       
   658                     }
       
   659                     $function = $this->smarty->registered_plugins[Smarty::PLUGIN_COMPILER][$tag][0];
       
   660                     if (!is_array($function)) {
       
   661                         return $function($args, $this);
       
   662                     } elseif (is_object($function[0])) {
       
   663                         return $this->smarty->registered_plugins[Smarty::PLUGIN_COMPILER][$tag][0][0]->$function[1]($args, $this);
       
   664                     } else {
       
   665                         return call_user_func_array($function, array($args, $this));
       
   666                     }
       
   667                 }
       
   668                 if ($this->smarty->loadPlugin('smarty_compiler_' . $tag)) {
       
   669                     $plugin = 'smarty_compiler_' . $tag;
       
   670                     if (is_callable($plugin)) {
       
   671                         return $plugin($args, $this->smarty);
       
   672                     }
       
   673                     if (class_exists($plugin, false)) {
       
   674                         $plugin_object = new $plugin;
       
   675                         if (method_exists($plugin_object, 'compile')) {
       
   676                             return $plugin_object->compile($args, $this);
       
   677                         }
       
   678                     }
       
   679                     throw new SmartyException("Plugin \"{$tag}\" not callable");
       
   680                 }
       
   681             }
       
   682             $this->trigger_template_error("unknown tag \"" . $tag . "\"", $this->lex->taglineno);
       
   683         }
       
   684     }
       
   685 
       
   686     /**
       
   687      * compile variable
       
   688      *
       
   689      * @param string $variable
       
   690      *
       
   691      * @return string
       
   692      */
       
   693     public function compileVariable($variable) {
       
   694         if (strpos($variable, '(') == 0) {
       
   695             // not a variable variable
       
   696             $var = trim($variable, '\'');
       
   697             $this->tag_nocache = $this->tag_nocache | $this->template->getVariable($var, null, true, false)->nocache;
       
   698             $this->template->properties['variables'][$var] = $this->tag_nocache | $this->nocache;
       
   699         }
       
   700         return '$_smarty_tpl->tpl_vars[' . $variable . ']->value';
       
   701     }
       
   702 
       
   703     /**
       
   704      * This method is called from parser to process a text content section
       
   705      * - remove text from inheritance child templates as they may generate output
       
   706      * - strip text if strip is enabled
       
   707      *
       
   708      * @param string $text
       
   709      *
       
   710      * @return null|\Smarty_Internal_ParseTree_Text
       
   711      */
       
   712     public function processText($text) {
       
   713         if ($this->parser->strip) {
       
   714             return new Smarty_Internal_ParseTree_Text($this->parser, preg_replace($this->stripRegEx, '', $text));
       
   715         } else {
       
   716             return new Smarty_Internal_ParseTree_Text($this->parser, $text);
       
   717         }
       
   718     }
       
   719 
       
   720     /**
       
   721      * lazy loads internal compile plugin for tag and calls the compile method
       
   722      * compile objects cached for reuse.
       
   723      * class name format:  Smarty_Internal_Compile_TagName
       
   724      * plugin filename format: Smarty_Internal_Tagname.php
       
   725      *
       
   726      * @param  string $tag tag name
       
   727      * @param  array $args list of tag attributes
       
   728      * @param  mixed $param1 optional parameter
       
   729      * @param  mixed $param2 optional parameter
       
   730      * @param  mixed $param3 optional parameter
       
   731      *
       
   732      * @return string compiled code
       
   733      */
       
   734     public function callTagCompiler($tag, $args, $param1 = null, $param2 = null, $param3 = null) {
       
   735         // check if tag allowed by security
       
   736         if (!isset($this->smarty->security_policy) || $this->smarty->security_policy->isTrustedTag($tag, $this)) {
       
   737             // re-use object if already exists
       
   738             if (!isset(self::$_tag_objects[$tag])) {
       
   739                 // lazy load internal compiler plugin
       
   740                 $class_name = 'Smarty_Internal_Compile_' . $tag;
       
   741                 if ($this->smarty->loadPlugin($class_name)) {
       
   742                     self::$_tag_objects[$tag] = new $class_name;
       
   743                 } else {
       
   744                     return false;
       
   745                 }
       
   746             }
       
   747             // compile this tag
       
   748             return self::$_tag_objects[$tag]->compile($args, $this, $param1, $param2, $param3);
       
   749         }
       
   750         // no internal compile plugin for this tag
       
   751         return false;
       
   752     }
       
   753 
       
   754     /**
       
   755      * Check for plugins and return function name
       
   756      *
       
   757      * @param         $plugin_name
       
   758      * @param  string $plugin_type type of plugin
       
   759      *
       
   760      * @return string call name of function
       
   761      */
       
   762     public function getPlugin($plugin_name, $plugin_type) {
       
   763         $function = null;
       
   764         if ($this->template->caching && ($this->nocache || $this->tag_nocache)) {
       
   765             if (isset($this->template->required_plugins['nocache'][$plugin_name][$plugin_type])) {
       
   766                 $function = $this->template->required_plugins['nocache'][$plugin_name][$plugin_type]['function'];
       
   767             } elseif (isset($this->template->required_plugins['compiled'][$plugin_name][$plugin_type])) {
       
   768                 $this->template->required_plugins['nocache'][$plugin_name][$plugin_type] = $this->template->required_plugins['compiled'][$plugin_name][$plugin_type];
       
   769                 $function = $this->template->required_plugins['nocache'][$plugin_name][$plugin_type]['function'];
       
   770             }
       
   771         } else {
       
   772             if (isset($this->template->required_plugins['compiled'][$plugin_name][$plugin_type])) {
       
   773                 $function = $this->template->required_plugins['compiled'][$plugin_name][$plugin_type]['function'];
       
   774             } elseif (isset($this->template->required_plugins['nocache'][$plugin_name][$plugin_type])) {
       
   775                 $this->template->required_plugins['compiled'][$plugin_name][$plugin_type] = $this->template->required_plugins['nocache'][$plugin_name][$plugin_type];
       
   776                 $function = $this->template->required_plugins['compiled'][$plugin_name][$plugin_type]['function'];
       
   777             }
       
   778         }
       
   779         if (isset($function)) {
       
   780             if ($plugin_type == 'modifier') {
       
   781                 $this->modifier_plugins[$plugin_name] = true;
       
   782             }
       
   783 
       
   784             return $function;
       
   785         }
       
   786         // loop through plugin dirs and find the plugin
       
   787         $function = 'smarty_' . $plugin_type . '_' . $plugin_name;
       
   788         $file = $this->smarty->loadPlugin($function, false);
       
   789 
       
   790         if (is_string($file)) {
       
   791             if ($this->template->caching && ($this->nocache || $this->tag_nocache)) {
       
   792                 $this->template->required_plugins['nocache'][$plugin_name][$plugin_type]['file'] = $file;
       
   793                 $this->template->required_plugins['nocache'][$plugin_name][$plugin_type]['function'] = $function;
       
   794             } else {
       
   795                 $this->template->required_plugins['compiled'][$plugin_name][$plugin_type]['file'] = $file;
       
   796                 $this->template->required_plugins['compiled'][$plugin_name][$plugin_type]['function'] = $function;
       
   797             }
       
   798             if ($plugin_type == 'modifier') {
       
   799                 $this->modifier_plugins[$plugin_name] = true;
       
   800             }
       
   801 
       
   802             return $function;
       
   803         }
       
   804         if (is_callable($function)) {
       
   805             // plugin function is defined in the script
       
   806             return $function;
       
   807         }
       
   808 
       
   809         return false;
       
   810     }
       
   811 
       
   812     /**
       
   813      * Check for plugins by default plugin handler
       
   814      *
       
   815      * @param  string $tag name of tag
       
   816      * @param  string $plugin_type type of plugin
       
   817      *
       
   818      * @return boolean true if found
       
   819      */
       
   820     public function getPluginFromDefaultHandler($tag, $plugin_type) {
       
   821         $callback = null;
       
   822         $script = null;
       
   823         $cacheable = true;
       
   824         $result = call_user_func_array($this->smarty->default_plugin_handler_func, array($tag, $plugin_type, $this->template, &$callback, &$script, &$cacheable));
       
   825         if ($result) {
       
   826             $this->tag_nocache = $this->tag_nocache || !$cacheable;
       
   827             if ($script !== null) {
       
   828                 if (is_file($script)) {
       
   829                     if ($this->template->caching && ($this->nocache || $this->tag_nocache)) {
       
   830                         $this->template->required_plugins['nocache'][$tag][$plugin_type]['file'] = $script;
       
   831                         $this->template->required_plugins['nocache'][$tag][$plugin_type]['function'] = $callback;
       
   832                     } else {
       
   833                         $this->template->required_plugins['compiled'][$tag][$plugin_type]['file'] = $script;
       
   834                         $this->template->required_plugins['compiled'][$tag][$plugin_type]['function'] = $callback;
       
   835                     }
       
   836                     require_once $script;
       
   837                 } else {
       
   838                     $this->trigger_template_error("Default plugin handler: Returned script file \"{$script}\" for \"{$tag}\" not found");
       
   839                 }
       
   840             }
       
   841             if (!is_string($callback) && !(is_array($callback) && is_string($callback[0]) && is_string($callback[1]))) {
       
   842                 $this->trigger_template_error("Default plugin handler: Returned callback for \"{$tag}\" must be a static function name or array of class and function name");
       
   843             }
       
   844             if (is_callable($callback)) {
       
   845                 $this->default_handler_plugins[$plugin_type][$tag] = array($callback, true, array());
       
   846 
       
   847                 return true;
       
   848             } else {
       
   849                 $this->trigger_template_error("Default plugin handler: Returned callback for \"{$tag}\" not callable");
       
   850             }
       
   851         }
       
   852 
       
   853         return false;
       
   854     }
       
   855 
       
   856     /**
       
   857      * Append code segments and remove unneeded ?> <?php transitions
       
   858      *
       
   859      * @param string $left
       
   860      * @param string $right
       
   861      *
       
   862      * @return string
       
   863      */
       
   864     public function appendCode($left, $right) {
       
   865         if (preg_match('/\s*\?>\s*$/', $left) && preg_match('/^\s*<\?php\s+/', $right)) {
       
   866             $left = preg_replace('/\s*\?>\s*$/', "\n", $left);
       
   867             $left .= preg_replace('/^\s*<\?php\s+/', '', $right);
       
   868         } else {
       
   869             $left .= $right;
       
   870         }
       
   871         return $left;
       
   872     }
       
   873 
       
   874     /**
       
   875      * Inject inline code for nocache template sections
       
   876      * This method gets the content of each template element from the parser.
       
   877      * If the content is compiled code and it should be not cached the code is injected
       
   878      * into the rendered output.
       
   879      *
       
   880      * @param  string $content content of template element
       
   881      * @param  boolean $is_code true if content is compiled code
       
   882      *
       
   883      * @return string  content
       
   884      */
       
   885     public function processNocacheCode($content, $is_code) {
       
   886         // If the template is not evaluated and we have a nocache section and or a nocache tag
       
   887         if ($is_code && !empty($content)) {
       
   888             // generate replacement code
       
   889             if ((!($this->template->source->recompiled) || $this->forceNocache) && $this->template->caching && !$this->suppressNocacheProcessing && ($this->nocache || $this->tag_nocache)
       
   890             ) {
       
   891                 $this->template->has_nocache_code = true;
       
   892                 $_output = addcslashes($content, '\'\\');
       
   893                 $_output = str_replace("^#^", "'", $_output);
       
   894                 $_output = "<?php echo '/*%%SmartyNocache:{$this->nocache_hash}%%*/" . $_output . "/*/%%SmartyNocache:{$this->nocache_hash}%%*/';?>\n";
       
   895                 // make sure we include modifier plugins for nocache code
       
   896                 foreach ($this->modifier_plugins as $plugin_name => $dummy) {
       
   897                     if (isset($this->template->required_plugins['compiled'][$plugin_name]['modifier'])) {
       
   898                         $this->template->required_plugins['nocache'][$plugin_name]['modifier'] = $this->template->required_plugins['compiled'][$plugin_name]['modifier'];
       
   899                     }
       
   900                 }
       
   901             } else {
       
   902                 $_output = $content;
       
   903             }
       
   904         } else {
       
   905             $_output = $content;
       
   906         }
       
   907         $this->modifier_plugins = array();
       
   908         $this->suppressNocacheProcessing = false;
       
   909         $this->tag_nocache = false;
       
   910 
       
   911         return $_output;
       
   912     }
       
   913 
       
   914     /**
       
   915      * Generate nocache code string
       
   916      *
       
   917      * @param string $code PHP code
       
   918      *
       
   919      * @return string
       
   920      */
       
   921     public function makeNocacheCode($code) {
       
   922         return "echo '/*%%SmartyNocache:{$this->nocache_hash}%%*/<?php " . str_replace("^#^", "'", addcslashes($code, '\'\\')) . "?>/*/%%SmartyNocache:{$this->nocache_hash}%%*/';\n";
       
   923     }
       
   924 
       
   925     /**
       
   926      *  push current file and line offset on stack for tracing {block} source lines
       
   927      *
       
   928      * @param string $file new filename
       
   929      * @param string $uid uid of file
       
   930      * @param int $line line offset to source
       
   931      * @param bool $debug false debug end_compile shall not be called
       
   932      */
       
   933     public function pushTrace($file, $uid, $line, $debug = true) {
       
   934         if ($this->smarty->debugging && $debug) {
       
   935             Smarty_Internal_Debug::end_compile($this->template);
       
   936         }
       
   937         array_push($this->trace_stack, array($this->smarty->_current_file, $this->trace_filepath, $this->trace_uid, $this->trace_line_offset));
       
   938         $this->trace_filepath = $this->smarty->_current_file = $file;
       
   939         $this->trace_uid = $uid;
       
   940         $this->trace_line_offset = $line;
       
   941         if ($this->smarty->debugging) {
       
   942             Smarty_Internal_Debug::start_compile($this->template);
       
   943         }
       
   944     }
       
   945 
       
   946     /**
       
   947      *  restore file and line offset
       
   948      */
       
   949     public function popTrace() {
       
   950         if ($this->smarty->debugging) {
       
   951             Smarty_Internal_Debug::end_compile($this->template);
       
   952         }
       
   953         $r = array_pop($this->trace_stack);
       
   954         $this->smarty->_current_file = $r[0];
       
   955         $this->trace_filepath = $r[1];
       
   956         $this->trace_uid = $r[2];
       
   957         $this->trace_line_offset = $r[3];
       
   958         if ($this->smarty->debugging) {
       
   959             Smarty_Internal_Debug::start_compile($this->template);
       
   960         }
       
   961     }
       
   962 
       
   963     /**
       
   964      * display compiler error messages without dying
       
   965      * If parameter $args is empty it is a parser detected syntax error.
       
   966      * In this case the parser is called to obtain information about expected tokens.
       
   967      * If parameter $args contains a string this is used as error message
       
   968      *
       
   969      * @param  string $args individual error message or null
       
   970      * @param  string $line line-number
       
   971      *
       
   972      * @throws SmartyCompilerException when an unexpected token is found
       
   973      */
       
   974     public function trigger_template_error($args = null, $line = null) {
       
   975         // get template source line which has error
       
   976         if (!isset($line)) {
       
   977             $line = $this->lex->line;
       
   978         }
       
   979         //        $line += $this->trace_line_offset;
       
   980         $match = preg_split("/\n/", $this->lex->data);
       
   981         $error_text = 'Syntax error in template "' . (empty($this->trace_filepath) ? $this->template->source->filepath : $this->trace_filepath) . '"  on line ' . ($line + $this->trace_line_offset) . ' "' . trim(preg_replace('![\t\r\n]+!', ' ', $match[$line - 1])) . '" ';
       
   982         if (isset($args)) {
       
   983             // individual error message
       
   984             $error_text .= $args;
       
   985         } else {
       
   986             $expect = array();
       
   987             // expected token from parser
       
   988             $error_text .= ' - Unexpected "' . $this->lex->value . '"';
       
   989             if (count($this->parser->yy_get_expected_tokens($this->parser->yymajor)) <= 4) {
       
   990                 foreach ($this->parser->yy_get_expected_tokens($this->parser->yymajor) as $token) {
       
   991                     $exp_token = $this->parser->yyTokenName[$token];
       
   992                     if (isset($this->lex->smarty_token_names[$exp_token])) {
       
   993                         // token type from lexer
       
   994                         $expect[] = '"' . $this->lex->smarty_token_names[$exp_token] . '"';
       
   995                     } else {
       
   996                         // otherwise internal token name
       
   997                         $expect[] = $this->parser->yyTokenName[$token];
       
   998                     }
       
   999                 }
       
  1000                 $error_text .= ', expected one of: ' . implode(' , ', $expect);
       
  1001             }
       
  1002         }
       
  1003         $e = new SmartyCompilerException($error_text);
       
  1004         $e->line = $line;
       
  1005         $e->source = trim(preg_replace('![\t\r\n]+!', ' ', $match[$line - 1]));
       
  1006         $e->desc = $args;
       
  1007         $e->template = $this->template->source->filepath;
       
  1008         throw $e;
       
  1009     }
       
  1010 }