lib/api/smarty/sysplugins/smarty_internal_compile_block.php

   1 <?php
   2
   3 /**
   4  * Smarty Internal Plugin Compile Block
   5  * Compiles the {block}{/block} tags
   6  *
   7  * @package    Smarty
   8  * @subpackage Compiler
   9  * @author     Uwe Tews
  10  */
  11
  12 /**
  13  * Smarty Internal Plugin Compile Block Class
  14  *
  15  * @package    Smarty
  16  * @subpackage Compiler
  17  */
  18 class Smarty_Internal_Compile_Block extends Smarty_Internal_CompileBase
  19 {
  20
  21     const parent = '____SMARTY_BLOCK_PARENT____';
  22     /**
  23      * Attribute definition: Overwrites base class.
  24      *
  25      * @var array
  26      * @see Smarty_Internal_CompileBase
  27      */
  28     public $required_attributes = array('name');
  29
  30     /**
  31      * Attribute definition: Overwrites base class.
  32      *
  33      * @var array
  34      * @see Smarty_Internal_CompileBase
  35      */
  36     public $shorttag_order = array('name');
  37
  38     /**
  39      * Attribute definition: Overwrites base class.
  40      *
  41      * @var array
  42      * @see Smarty_Internal_CompileBase
  43      */
  44     public $option_flags = array('hide', 'append', 'prepend', 'nocache');
  45
  46     /**
  47      * Attribute definition: Overwrites base class.
  48      *
  49      * @var array
  50      * @see Smarty_Internal_CompileBase
  51      */
  52     public $optional_attributes = array('internal_file', 'internal_uid', 'internal_line');
  53     /**
  54      * nested child block names
  55      *
  56      * @var array
  57      */
  58     public static $nested_block_names = array();
  59
  60     /**
  61      * child block source buffer
  62      *
  63      * @var array
  64      */
  65     public static $block_data = array();
  66
  67     /**
  68      * Compiles code for the {block} tag
  69      *
  70      * @param array  $args     array with attributes from parser
  71      * @param object $compiler compiler object
  72      *
  73      * @return boolean true
  74      */
  75     public function compile($args, $compiler)
  76     {
  77         // check and get attributes
  78         $_attr = $this->getAttributes($compiler, $args);
  79         $_name = trim($_attr['name'], "\"'");
  80
  81         // existing child must override parent settings
  82         if (isset($compiler->template->block_data[$_name]) && $compiler->template->block_data[$_name]['mode'] == 'replace') {
  83             $_attr['append'] = false;
  84             $_attr['prepend'] = false;
  85         }
  86
  87         // check if we process an inheritance child template
  88         if ($compiler->inheritance_child) {
  89             array_unshift(self::$nested_block_names, $_name);
  90             // build {block} for child block
  91             self::$block_data[$_name]['source'] =
  92                 "{$compiler->smarty->left_delimiter}private_child_block name={$_attr['name']} file='{$compiler->template->source->filepath}' type='{$compiler->template->source->type}' resource='{$compiler->template->template_resource}'" .
  93                 " uid='{$compiler->template->source->uid}' line={$compiler->lex->line}";
  94             if ($_attr['nocache']) {
  95                 self::$block_data[$_name]['source'] .= ' nocache';
  96             }
  97             self::$block_data[$_name]['source'] .= $compiler->smarty->right_delimiter;
  98
  99             $save = array($_attr, $compiler->inheritance);
 100             $this->openTag($compiler, 'block', $save);
 101             // set flag for {block} tag
 102             $compiler->inheritance = true;
 103             $compiler->lex->yypushstate(Smarty_Internal_Templatelexer::CHILDBLOCK);
 104             $compiler->has_code = false;
 105             return;
 106         }
 107         // must merge includes
 108         if ($_attr['nocache'] == true) {
 109             $compiler->tag_nocache = true;
 110         }
 111         $save = array($_attr, $compiler->inheritance, $compiler->parser->current_buffer, $compiler->nocache);
 112         $this->openTag($compiler, 'block', $save);
 113         $compiler->inheritance = true;
 114         $compiler->nocache = $compiler->nocache | $compiler->tag_nocache;
 115
 116         $compiler->parser->current_buffer = new _smarty_template_buffer($compiler->parser);
 117         $compiler->has_code = false;
 118
 119         return true;
 120     }
 121
 122     /**
 123      * Compile saved child block source
 124      *
 125      * @param object $compiler compiler object
 126      * @param string $_name    optional name of child block
 127      *
 128      * @return string   compiled code of child block
 129      */
 130     static function compileChildBlock($compiler, $_name = null)
 131     {
 132         if ($compiler->inheritance_child) {
 133             $name1 = Smarty_Internal_Compile_Block::$nested_block_names[0];
 134             if (isset($compiler->template->block_data[$name1])) {
 135                 //  replace inner block name with generic
 136                 Smarty_Internal_Compile_Block::$block_data[$name1]['source'] .= $compiler->template->block_data[$name1]['source'];
 137                 Smarty_Internal_Compile_Block::$block_data[$name1]['child'] = true;
 138             }
 139             $compiler->lex->yypushstate(Smarty_Internal_Templatelexer::CHILDBLOCK);
 140             $compiler->has_code = false;
 141             return;
 142         }
 143         // if called by {$smarty.block.child} we must search the name of enclosing {block}
 144         if ($_name == null) {
 145             $stack_count = count($compiler->_tag_stack);
 146             while (--$stack_count >= 0) {
 147                 if ($compiler->_tag_stack[$stack_count][0] == 'block') {
 148                     $_name = trim($compiler->_tag_stack[$stack_count][1][0]['name'], "\"'");
 149                     break;
 150                 }
 151             }
 152         }
 153         if ($_name == null) {
 154             $compiler->trigger_template_error(' tag {$smarty.block.child} used outside {block} tags ', $compiler->lex->taglineno);
 155         }
 156         // undefined child?
 157         if (!isset($compiler->template->block_data[$_name]['source'])) {
 158             $compiler->popTrace();
 159             return '';
 160         }
 161         // flag that child is already compile by {$smarty.block.child} inclusion
 162         $compiler->template->block_data[$_name]['compiled'] = true;
 163         $_tpl = new Smarty_Internal_template('string:' . $compiler->template->block_data[$_name]['source'], $compiler->smarty, $compiler->template, $compiler->template->cache_id,
 164                                              $compiler->template->compile_id, $compiler->template->caching, $compiler->template->cache_lifetime);
 165         if ($compiler->smarty->debugging) {
 166             Smarty_Internal_Debug::ignore($_tpl);
 167         }
 168         $_tpl->tpl_vars = $compiler->template->tpl_vars;
 169         $_tpl->variable_filters = $compiler->template->variable_filters;
 170         $_tpl->properties['nocache_hash'] = $compiler->template->properties['nocache_hash'];
 171         $_tpl->allow_relative_path = true;
 172         $_tpl->compiler->inheritance = true;
 173         $_tpl->compiler->suppressHeader = true;
 174         $_tpl->compiler->suppressFilter = true;
 175         $_tpl->compiler->suppressTemplatePropertyHeader = true;
 176         $_tpl->compiler->suppressMergedTemplates = true;
 177         $nocache = $compiler->nocache || $compiler->tag_nocache;
 178         if (strpos($compiler->template->block_data[$_name]['source'], self::parent) !== false) {
 179             $_output = str_replace(self::parent, $compiler->parser->current_buffer->to_smarty_php(), $_tpl->compiler->compileTemplate($_tpl, $nocache));
 180         } elseif ($compiler->template->block_data[$_name]['mode'] == 'prepend') {
 181             $_output = $_tpl->compiler->compileTemplate($_tpl, $nocache) . $compiler->parser->current_buffer->to_smarty_php();
 182         } elseif ($compiler->template->block_data[$_name]['mode'] == 'append') {
 183             $_output = $compiler->parser->current_buffer->to_smarty_php() . $_tpl->compiler->compileTemplate($_tpl, $nocache);
 184         } elseif (!empty($compiler->template->block_data[$_name])) {
 185             $_output = $_tpl->compiler->compileTemplate($_tpl, $nocache);
 186         }
 187         $compiler->template->properties['file_dependency'] = array_merge($compiler->template->properties['file_dependency'], $_tpl->properties['file_dependency']);
 188         $compiler->template->properties['function'] = array_merge($compiler->template->properties['function'], $_tpl->properties['function']);
 189         $compiler->merged_templates = array_merge($compiler->merged_templates, $_tpl->compiler->merged_templates);
 190         $compiler->template->variable_filters = $_tpl->variable_filters;
 191         if ($_tpl->has_nocache_code) {
 192             $compiler->template->has_nocache_code = true;
 193         }
 194         foreach ($_tpl->required_plugins as $key => $tmp1) {
 195             if ($compiler->nocache && $compiler->template->caching) {
 196                 $code = 'nocache';
 197             } else {
 198                 $code = $key;
 199             }
 200             foreach ($tmp1 as $name => $tmp) {
 201                 foreach ($tmp as $type => $data) {
 202                     $compiler->template->required_plugins[$code][$name][$type] = $data;
 203                 }
 204             }
 205         }
 206         unset($_tpl);
 207         $compiler->has_code = true;
 208         return $_output;
 209     }
 210
 211     /**
 212      * Compile $smarty.block.parent
 213      *
 214      * @param object $compiler compiler object
 215      * @param string $_name    optional name of child block
 216      *
 217      * @return string   compiled code of child block
 218      */
 219     static function compileParentBlock($compiler, $_name = null)
 220     {
 221         // if called by {$smarty.block.parent} we must search the name of enclosing {block}
 222         if ($_name == null) {
 223             $stack_count = count($compiler->_tag_stack);
 224             while (--$stack_count >= 0) {
 225                 if ($compiler->_tag_stack[$stack_count][0] == 'block') {
 226                     $_name = trim($compiler->_tag_stack[$stack_count][1][0]['name'], "\"'");
 227                     break;
 228                 }
 229             }
 230         }
 231         if ($_name == null) {
 232             $compiler->trigger_template_error(' tag {$smarty.block.parent} used outside {block} tags ', $compiler->lex->taglineno);
 233         }
 234         if (empty(Smarty_Internal_Compile_Block::$nested_block_names)) {
 235             $compiler->trigger_template_error(' illegal {$smarty.block.parent} in parent template ', $compiler->lex->taglineno);
 236         }
 237         Smarty_Internal_Compile_Block::$block_data[Smarty_Internal_Compile_Block::$nested_block_names[0]]['source'] .= Smarty_Internal_Compile_Block::parent;
 238         $compiler->lex->yypushstate(Smarty_Internal_Templatelexer::CHILDBLOCK);
 239         $compiler->has_code = false;
 240         return;
 241     }
 242
 243     /**
 244      * Process block source
 245      *
 246      * @param        $compiler
 247      * @param string $source source text
 248      *
 249      */
 250     static function blockSource($compiler, $source)
 251     {
 252         Smarty_Internal_Compile_Block::$block_data[Smarty_Internal_Compile_Block::$nested_block_names[0]]['source'] .= $source;
 253     }
 254 }
 255
 256 /**
 257  * Smarty Internal Plugin Compile BlockClose Class
 258  *
 259  * @package    Smarty
 260  * @subpackage Compiler
 261  */
 262 class Smarty_Internal_Compile_Blockclose extends Smarty_Internal_CompileBase
 263 {
 264     /**
 265      * Compiles code for the {/block} tag
 266      *
 267      * @param array  $args     array with attributes from parser
 268      * @param object $compiler compiler object
 269      *
 270      * @return string compiled code
 271      */
 272     public function compile($args, $compiler)
 273     {
 274         $compiler->has_code = true;
 275         // check and get attributes
 276         $_attr = $this->getAttributes($compiler, $args);
 277         $saved_data = $this->closeTag($compiler, array('block'));
 278         $_name = trim($saved_data[0]['name'], "\"'");
 279         // reset flag for {block} tag
 280         $compiler->inheritance = $saved_data[1];
 281         // check if we process an inheritance child template
 282         if ($compiler->inheritance_child) {
 283             $name1 = Smarty_Internal_Compile_Block::$nested_block_names[0];
 284             Smarty_Internal_Compile_Block::$block_data[$name1]['source'] .= "{$compiler->smarty->left_delimiter}/private_child_block{$compiler->smarty->right_delimiter}";
 285             array_shift(Smarty_Internal_Compile_Block::$nested_block_names);
 286             if (!empty(Smarty_Internal_Compile_Block::$nested_block_names)) {
 287                 $name2 = Smarty_Internal_Compile_Block::$nested_block_names[0];
 288                 if (isset($compiler->template->block_data[$name1]) || !$saved_data[0]['hide']) {
 289                     if (isset(Smarty_Internal_Compile_Block::$block_data[$name1]['child']) || !isset($compiler->template->block_data[$name1])) {
 290                         Smarty_Internal_Compile_Block::$block_data[$name2]['source'] .= Smarty_Internal_Compile_Block::$block_data[$name1]['source'];
 291                     } else {
 292                         if ($compiler->template->block_data[$name1]['mode'] == 'append') {
 293                             Smarty_Internal_Compile_Block::$block_data[$name2]['source'] .= Smarty_Internal_Compile_Block::$block_data[$name1]['source'] . $compiler->template->block_data[$name1]['source'];
 294                         } elseif ($compiler->template->block_data[$name1]['mode'] == 'prepend') {
 295                             Smarty_Internal_Compile_Block::$block_data[$name2]['source'] .= $compiler->template->block_data[$name1]['source'] . Smarty_Internal_Compile_Block::$block_data[$name1]['source'];
 296                         } else {
 297                             Smarty_Internal_Compile_Block::$block_data[$name2]['source'] .= $compiler->template->block_data[$name1]['source'];
 298                         }
 299                     }
 300                 }
 301                 unset(Smarty_Internal_Compile_Block::$block_data[$name1]);
 302                 $compiler->lex->yypushstate(Smarty_Internal_Templatelexer::CHILDBLOCK);
 303             } else {
 304                 if (isset($compiler->template->block_data[$name1]) || !$saved_data[0]['hide']) {
 305                     if (isset($compiler->template->block_data[$name1]) && !isset(Smarty_Internal_Compile_Block::$block_data[$name1]['child'])) {
 306                         if (strpos($compiler->template->block_data[$name1]['source'], Smarty_Internal_Compile_Block::parent) !== false) {
 307                             $compiler->template->block_data[$name1]['source'] =
 308                                 str_replace(Smarty_Internal_Compile_Block::parent, Smarty_Internal_Compile_Block::$block_data[$name1]['source'], $compiler->template->block_data[$name1]['source']);
 309                         } elseif ($compiler->template->block_data[$name1]['mode'] == 'prepend') {
 310                             $compiler->template->block_data[$name1]['source'] .= Smarty_Internal_Compile_Block::$block_data[$name1]['source'];
 311                         } elseif ($compiler->template->block_data[$name1]['mode'] == 'append') {
 312                             $compiler->template->block_data[$name1]['source'] = Smarty_Internal_Compile_Block::$block_data[$name1]['source'] . $compiler->template->block_data[$name1]['source'];
 313                         }
 314                     } else {
 315                         $compiler->template->block_data[$name1]['source'] = Smarty_Internal_Compile_Block::$block_data[$name1]['source'];
 316                     }
 317                     $compiler->template->block_data[$name1]['mode'] = 'replace';
 318                     if ($saved_data[0]['append']) {
 319                         $compiler->template->block_data[$name1]['mode'] = 'append';
 320                     }
 321                     if ($saved_data[0]['prepend']) {
 322                         $compiler->template->block_data[$name1]['mode'] = 'prepend';
 323                     }
 324                 }
 325                 unset(Smarty_Internal_Compile_Block::$block_data[$name1]);
 326                 $compiler->lex->yypushstate(Smarty_Internal_Templatelexer::CHILDBODY);
 327             }
 328             $compiler->has_code = false;
 329             return;
 330         }
 331         if (isset($compiler->template->block_data[$_name]) && !isset($compiler->template->block_data[$_name]['compiled'])) {
 332             $_output = Smarty_Internal_Compile_Block::compileChildBlock($compiler, $_name);
 333         } else {
 334             if ($saved_data[0]['hide'] && !isset($compiler->template->block_data[$_name]['source'])) {
 335                 $_output = '';
 336             } else {
 337                 $_output = $compiler->parser->current_buffer->to_smarty_php();
 338             }
 339         }
 340         unset($compiler->template->block_data[$_name]['compiled']);
 341         // reset flags
 342         $compiler->parser->current_buffer = $saved_data[2];
 343         if ($compiler->nocache) {
 344             $compiler->tag_nocache = true;
 345         }
 346         $compiler->nocache = $saved_data[3];
 347         // $_output content has already nocache code processed
 348         $compiler->suppressNocacheProcessing = true;
 349
 350         return $_output;
 351     }
 352 }
 353
 354 /**
 355  * Smarty Internal Plugin Compile Child Block Class
 356  *
 357  * @package    Smarty
 358  * @subpackage Compiler
 359  */
 360 class Smarty_Internal_Compile_Private_Child_Block extends Smarty_Internal_CompileBase
 361 {
 362
 363     /**
 364      * Attribute definition: Overwrites base class.
 365      *
 366      * @var array
 367      * @see Smarty_Internal_CompileBase
 368      */
 369     public $required_attributes = array('name', 'file', 'uid', 'line', 'type', 'resource');
 370
 371     /**
 372      * Compiles code for the {private_child_block} tag
 373      *
 374      * @param array  $args     array with attributes from parser
 375      * @param object $compiler compiler object
 376      *
 377      * @return boolean true
 378      */
 379     public function compile($args, $compiler)
 380     {
 381         // check and get attributes
 382         $_attr = $this->getAttributes($compiler, $args);
 383
 384         // update template with original template resource of {block}
 385         if (trim($_attr['type'], "'") == 'file') {
 386             $compiler->template->template_resource = 'file:' . realpath(trim($_attr['file'], "'"));
 387         } else {
 388             $compiler->template->template_resource = trim($_attr['resource'], "'");
 389         }
 390         // source object
 391         unset ($compiler->template->source);
 392         $exists = $compiler->template->source->exists;
 393
 394         // must merge includes
 395         if ($_attr['nocache'] == true) {
 396             $compiler->tag_nocache = true;
 397         }
 398         $save = array($_attr, $compiler->nocache);
 399
 400         // set trace back to child block
 401         $compiler->pushTrace(trim($_attr['file'], "\"'"), trim($_attr['uid'], "\"'"), $_attr['line'] - $compiler->lex->line);
 402
 403         $this->openTag($compiler, 'private_child_block', $save);
 404
 405         $compiler->nocache = $compiler->nocache | $compiler->tag_nocache;
 406         $compiler->has_code = false;
 407
 408         return true;
 409     }
 410 }
 411
 412 /**
 413  * Smarty Internal Plugin Compile Child Block Close Class
 414  *
 415  * @package    Smarty
 416  * @subpackage Compiler
 417  */
 418 class Smarty_Internal_Compile_Private_Child_Blockclose extends Smarty_Internal_CompileBase
 419 {
 420
 421     /**
 422      * Compiles code for the {/private_child_block} tag
 423      *
 424      * @param array  $args     array with attributes from parser
 425      * @param object $compiler compiler object
 426      *
 427      * @return boolean true
 428      */
 429     public function compile($args, $compiler)
 430     {
 431         // check and get attributes
 432         $_attr = $this->getAttributes($compiler, $args);
 433
 434         $saved_data = $this->closeTag($compiler, array('private_child_block'));
 435
 436         // end of child block
 437         $compiler->popTrace();
 438
 439         $compiler->nocache = $saved_data[1];
 440         $compiler->has_code = false;
 441
 442         return true;
 443     }
 444 }