library/Smarty/libs/sysplugins/smarty_internal_parsetree.php

   1 <?php
   2 /**
   3  * Smarty Internal Plugin Templateparser Parsetrees
   4  * These are classes to build parsetrees in the template parser
   5  *
   6  * @package    Smarty
   7  * @subpackage Compiler
   8  * @author     Thue Kristensen
   9  * @author     Uwe Tews
  10  */
  11
  12 /**
  13  * @package    Smarty
  14  * @subpackage Compiler
  15  * @ignore
  16  */
  17 abstract class _smarty_parsetree
  18 {
  19     /**
  20      * Parser object
  21      *
  22      * @var object
  23      */
  24     public $parser;
  25     /**
  26      * Buffer content
  27      *
  28      * @var mixed
  29      */
  30     public $data;
  31
  32     /**
  33      * Subtree array
  34      *
  35      * @var array
  36      */
  37     public $subtrees = array();
  38
  39     /**
  40      * Return buffer
  41      *
  42      * @return string buffer content
  43      */
  44     abstract public function to_smarty_php();
  45 }
  46
  47 /**
  48  * A complete smarty tag.
  49  *
  50  * @package    Smarty
  51  * @subpackage Compiler
  52  * @ignore
  53  */
  54 class _smarty_tag extends _smarty_parsetree
  55 {
  56     /**
  57      * Saved block nesting level
  58      *
  59      * @var int
  60      */
  61     public $saved_block_nesting;
  62
  63     /**
  64      * Create parse tree buffer for Smarty tag
  65      *
  66      * @param object $parser parser object
  67      * @param string $data   content
  68      */
  69     public function __construct($parser, $data)
  70     {
  71         $this->parser = $parser;
  72         $this->data = $data;
  73         $this->saved_block_nesting = $parser->block_nesting_level;
  74     }
  75
  76     /**
  77      * Return buffer content
  78      *
  79      * @return string content
  80      */
  81     public function to_smarty_php()
  82     {
  83         return $this->data;
  84     }
  85
  86     /**
  87      * Return complied code that loads the evaluated output of buffer content into a temporary variable
  88      *
  89      * @return string template code
  90      */
  91     public function assign_to_var()
  92     {
  93         $var = sprintf('$_tmp%d', ++Smarty_Internal_Templateparser::$prefix_number);
  94         $this->parser->compiler->prefix_code[] = sprintf('<?php ob_start();?>%s<?php %s=ob_get_clean();?>', $this->data, $var);
  95
  96         return $var;
  97     }
  98 }
  99
 100 /**
 101  * Code fragment inside a tag.
 102  *
 103  * @package    Smarty
 104  * @subpackage Compiler
 105  * @ignore
 106  */
 107 class _smarty_code extends _smarty_parsetree
 108 {
 109     /**
 110      * Create parse tree buffer for code fragment
 111      *
 112      * @param object $parser parser object
 113      * @param string $data   content
 114      */
 115     public function __construct($parser, $data)
 116     {
 117         $this->parser = $parser;
 118         $this->data = $data;
 119     }
 120
 121     /**
 122      * Return buffer content in parentheses
 123      *
 124      * @return string content
 125      */
 126     public function to_smarty_php()
 127     {
 128         return sprintf("(%s)", $this->data);
 129     }
 130 }
 131
 132 /**
 133  * Double quoted string inside a tag.
 134  *
 135  * @package    Smarty
 136  * @subpackage Compiler
 137  * @ignore
 138  */
 139 class _smarty_doublequoted extends _smarty_parsetree
 140 {
 141     /**
 142      * Create parse tree buffer for double quoted string subtrees
 143      *
 144      * @param object            $parser  parser object
 145      * @param _smarty_parsetree $subtree parsetree buffer
 146      */
 147     public function __construct($parser, _smarty_parsetree $subtree)
 148     {
 149         $this->parser = $parser;
 150         $this->subtrees[] = $subtree;
 151         if ($subtree instanceof _smarty_tag) {
 152             $this->parser->block_nesting_level = count($this->parser->compiler->_tag_stack);
 153         }
 154     }
 155
 156     /**
 157      * Append buffer to subtree
 158      *
 159      * @param _smarty_parsetree $subtree parsetree buffer
 160      */
 161     public function append_subtree(_smarty_parsetree $subtree)
 162     {
 163         $last_subtree = count($this->subtrees) - 1;
 164         if ($last_subtree >= 0 && $this->subtrees[$last_subtree] instanceof _smarty_tag && $this->subtrees[$last_subtree]->saved_block_nesting < $this->parser->block_nesting_level) {
 165             if ($subtree instanceof _smarty_code) {
 166                 $this->subtrees[$last_subtree]->data .= '<?php echo ' . $subtree->data . ';?>';
 167             } elseif ($subtree instanceof _smarty_dq_content) {
 168                 $this->subtrees[$last_subtree]->data .= '<?php echo "' . $subtree->data . '";?>';
 169             } else {
 170                 $this->subtrees[$last_subtree]->data .= $subtree->data;
 171             }
 172         } else {
 173             $this->subtrees[] = $subtree;
 174         }
 175         if ($subtree instanceof _smarty_tag) {
 176             $this->parser->block_nesting_level = count($this->parser->compiler->_tag_stack);
 177         }
 178     }
 179
 180     /**
 181      * Merge subtree buffer content together
 182      *
 183      * @return string compiled template code
 184      */
 185     public function to_smarty_php()
 186     {
 187         $code = '';
 188         foreach ($this->subtrees as $subtree) {
 189             if ($code !== "") {
 190                 $code .= ".";
 191             }
 192             if ($subtree instanceof _smarty_tag) {
 193                 $more_php = $subtree->assign_to_var();
 194             } else {
 195                 $more_php = $subtree->to_smarty_php();
 196             }
 197
 198             $code .= $more_php;
 199
 200             if (!$subtree instanceof _smarty_dq_content) {
 201                 $this->parser->compiler->has_variable_string = true;
 202             }
 203         }
 204
 205         return $code;
 206     }
 207 }
 208
 209 /**
 210  * Raw chars as part of a double quoted string.
 211  *
 212  * @package    Smarty
 213  * @subpackage Compiler
 214  * @ignore
 215  */
 216 class _smarty_dq_content extends _smarty_parsetree
 217 {
 218     /**
 219      * Create parse tree buffer with string content
 220      *
 221      * @param object $parser parser object
 222      * @param string $data   string section
 223      */
 224     public function __construct($parser, $data)
 225     {
 226         $this->parser = $parser;
 227         $this->data = $data;
 228     }
 229
 230     /**
 231      * Return content as double quoted string
 232      *
 233      * @return string doubled quoted string
 234      */
 235     public function to_smarty_php()
 236     {
 237         return '"' . $this->data . '"';
 238     }
 239 }
 240
 241 /**
 242  * Template element
 243  *
 244  * @package    Smarty
 245  * @subpackage Compiler
 246  * @ignore
 247  */
 248 class _smarty_template_buffer extends _smarty_parsetree
 249 {
 250     /**
 251      * Array of template elements
 252      *
 253      * @var array
 254      */
 255     public $subtrees = Array();
 256
 257     /**
 258      * Create root of parse tree for template elements
 259      *
 260      * @param object $parser parse object
 261      */
 262     public function __construct($parser)
 263     {
 264         $this->parser = $parser;
 265     }
 266
 267     /**
 268      * Append buffer to subtree
 269      *
 270      * @param _smarty_parsetree $subtree
 271      */
 272     public function append_subtree(_smarty_parsetree $subtree)
 273     {
 274         $this->subtrees[] = $subtree;
 275     }
 276
 277     /**
 278      * Sanitize and merge subtree buffers together
 279      *
 280      * @return string template code content
 281      */
 282     public function to_smarty_php()
 283     {
 284         $code = '';
 285         for ($key = 0, $cnt = count($this->subtrees); $key < $cnt; $key ++) {
 286             if ($key + 2 < $cnt) {
 287                 if ($this->subtrees[$key] instanceof _smarty_linebreak && $this->subtrees[$key + 1] instanceof _smarty_tag && $this->subtrees[$key + 1]->data == '' && $this->subtrees[$key + 2] instanceof _smarty_linebreak) {
 288                     $key = $key + 1;
 289                     continue;
 290                 }
 291                 if (substr($this->subtrees[$key]->data, - 1) == '<' && $this->subtrees[$key + 1]->data == '' && substr($this->subtrees[$key + 2]->data, - 1) == '?') {
 292                     $key = $key + 2;
 293                     continue;
 294                 }
 295             }
 296             if (substr($code, - 1) == '<') {
 297                 $subtree = $this->subtrees[$key]->to_smarty_php();
 298                 if (substr($subtree, 0, 1) == '?') {
 299                     $code = substr($code, 0, strlen($code) - 1) . '<<?php ?>?' . substr($subtree, 1);
 300                 } elseif ($this->parser->asp_tags && substr($subtree, 0, 1) == '%') {
 301                     $code = substr($code, 0, strlen($code) - 1) . '<<?php ?>%' . substr($subtree, 1);
 302                 } else {
 303                     $code .= $subtree;
 304                 }
 305                 continue;
 306             }
 307             if ($this->parser->asp_tags && substr($code, - 1) == '%') {
 308                 $subtree = $this->subtrees[$key]->to_smarty_php();
 309                 if (substr($subtree, 0, 1) == '>') {
 310                     $code = substr($code, 0, strlen($code) - 1) . '%<?php ?>>' . substr($subtree, 1);
 311                 } else {
 312                     $code .= $subtree;
 313                 }
 314                 continue;
 315             }
 316             if (substr($code, - 1) == '?') {
 317                 $subtree = $this->subtrees[$key]->to_smarty_php();
 318                 if (substr($subtree, 0, 1) == '>') {
 319                     $code = substr($code, 0, strlen($code) - 1) . '?<?php ?>>' . substr($subtree, 1);
 320                 } else {
 321                     $code .= $subtree;
 322                 }
 323                 continue;
 324             }
 325             $code .= $this->subtrees[$key]->to_smarty_php();
 326         }
 327
 328         return $code;
 329     }
 330 }
 331
 332 /**
 333  * template text
 334  *
 335  * @package    Smarty
 336  * @subpackage Compiler
 337  * @ignore
 338  */
 339 class _smarty_text extends _smarty_parsetree
 340 {
 341     /**
 342      * Create template text buffer
 343      *
 344      * @param object $parser parser object
 345      * @param string $data   text
 346      */
 347     public function __construct($parser, $data)
 348     {
 349         $this->parser = $parser;
 350         $this->data = $data;
 351     }
 352
 353     /**
 354      * Return buffer content
 355      *
 356      * @return strint text
 357      */
 358     public function to_smarty_php()
 359     {
 360         return $this->data;
 361     }
 362 }
 363
 364 /**
 365  * template linebreaks
 366  *
 367  * @package    Smarty
 368  * @subpackage Compiler
 369  * @ignore
 370  */
 371 class _smarty_linebreak extends _smarty_parsetree
 372 {
 373     /**
 374      * Create buffer with linebreak content
 375      *
 376      * @param object $parser parser object
 377      * @param string $data   linebreak string
 378      */
 379     public function __construct($parser, $data)
 380     {
 381         $this->parser = $parser;
 382         $this->data = $data;
 383     }
 384
 385     /**
 386      * Return linebrak
 387      *
 388      * @return string linebreak
 389      */
 390     public function to_smarty_php()
 391     {
 392         return $this->data;
 393     }
 394 }