[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Smarty Internal Plugin Data
   4   *
   5   * This file contains the basic classes and methodes for template and variable creation
   6   *
   7   * @package Smarty
   8   * @subpackage Template
   9   * @author Uwe Tews
  10   */
  11  
  12  /**
  13   * Base class with template and variable methodes
  14   *
  15   * @package Smarty
  16   * @subpackage Template
  17   */
  18  class Smarty_Internal_Data {
  19  
  20      /**
  21       * name of class used for templates
  22       *
  23       * @var string
  24       */
  25      public $template_class = 'Smarty_Internal_Template';
  26      /**
  27       * template variables
  28       *
  29       * @var array
  30       */
  31      public $tpl_vars = array();
  32      /**
  33       * parent template (if any)
  34       *
  35       * @var Smarty_Internal_Template
  36       */
  37      public $parent = null;
  38      /**
  39       * configuration settings
  40       *
  41       * @var array
  42       */
  43      public $config_vars = array();
  44  
  45      /**
  46       * assigns a Smarty variable
  47       *
  48       * @param array|string $tpl_var the template variable name(s)
  49       * @param mixed        $value   the value to assign
  50       * @param boolean      $nocache if true any output of this variable will be not cached
  51       * @param boolean $scope the scope the variable will have  (local,parent or root)
  52       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
  53       */
  54      public function assign($tpl_var, $value = null, $nocache = false)
  55      {
  56          if (is_array($tpl_var)) {
  57              foreach ($tpl_var as $_key => $_val) {
  58                  if ($_key != '') {
  59                      $this->tpl_vars[$_key] = new Smarty_variable($_val, $nocache);
  60                  }
  61              }
  62          } else {
  63              if ($tpl_var != '') {
  64                  $this->tpl_vars[$tpl_var] = new Smarty_variable($value, $nocache);
  65              }
  66          }
  67  
  68          return $this;
  69      }
  70  
  71      /**
  72       * assigns a global Smarty variable
  73       *
  74       * @param string $varname the global variable name
  75       * @param mixed  $value   the value to assign
  76       * @param boolean $nocache if true any output of this variable will be not cached
  77       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
  78       */
  79      public function assignGlobal($varname, $value = null, $nocache = false)
  80      {
  81          if ($varname != '') {
  82              Smarty::$global_tpl_vars[$varname] = new Smarty_variable($value, $nocache);
  83          }
  84  
  85          return $this;
  86      }
  87      /**
  88       * assigns values to template variables by reference
  89       *
  90       * @param string $tpl_var the template variable name
  91       * @param mixed $ &$value the referenced value to assign
  92       * @param boolean $nocache if true any output of this variable will be not cached
  93       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
  94       */
  95      public function assignByRef($tpl_var, &$value, $nocache = false)
  96      {
  97          if ($tpl_var != '') {
  98              $this->tpl_vars[$tpl_var] = new Smarty_variable(null, $nocache);
  99              $this->tpl_vars[$tpl_var]->value = &$value;
 100          }
 101  
 102          return $this;
 103      }
 104  
 105      /**
 106       * appends values to template variables
 107       *
 108       * @param array|string $tpl_var the template variable name(s)
 109       * @param mixed        $value   the value to append
 110       * @param boolean      $merge   flag if array elements shall be merged
 111       * @param boolean $nocache if true any output of this variable will be not cached
 112       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 113       */
 114      public function append($tpl_var, $value = null, $merge = false, $nocache = false)
 115      {
 116          if (is_array($tpl_var)) {
 117              // $tpl_var is an array, ignore $value
 118              foreach ($tpl_var as $_key => $_val) {
 119                  if ($_key != '') {
 120                      if (!isset($this->tpl_vars[$_key])) {
 121                          $tpl_var_inst = $this->getVariable($_key, null, true, false);
 122                          if ($tpl_var_inst instanceof Undefined_Smarty_Variable) {
 123                              $this->tpl_vars[$_key] = new Smarty_variable(null, $nocache);
 124                          } else {
 125                              $this->tpl_vars[$_key] = clone $tpl_var_inst;
 126                          }
 127                      }
 128                      if (!(is_array($this->tpl_vars[$_key]->value) || $this->tpl_vars[$_key]->value instanceof ArrayAccess)) {
 129                          settype($this->tpl_vars[$_key]->value, 'array');
 130                      }
 131                      if ($merge && is_array($_val)) {
 132                          foreach($_val as $_mkey => $_mval) {
 133                              $this->tpl_vars[$_key]->value[$_mkey] = $_mval;
 134                          }
 135                      } else {
 136                          $this->tpl_vars[$_key]->value[] = $_val;
 137                      }
 138                  }
 139              }
 140          } else {
 141              if ($tpl_var != '' && isset($value)) {
 142                  if (!isset($this->tpl_vars[$tpl_var])) {
 143                      $tpl_var_inst = $this->getVariable($tpl_var, null, true, false);
 144                      if ($tpl_var_inst instanceof Undefined_Smarty_Variable) {
 145                          $this->tpl_vars[$tpl_var] = new Smarty_variable(null, $nocache);
 146                      } else {
 147                          $this->tpl_vars[$tpl_var] = clone $tpl_var_inst;
 148                      }
 149                  }
 150                  if (!(is_array($this->tpl_vars[$tpl_var]->value) || $this->tpl_vars[$tpl_var]->value instanceof ArrayAccess)) {
 151                      settype($this->tpl_vars[$tpl_var]->value, 'array');
 152                  }
 153                  if ($merge && is_array($value)) {
 154                      foreach($value as $_mkey => $_mval) {
 155                          $this->tpl_vars[$tpl_var]->value[$_mkey] = $_mval;
 156                      }
 157                  } else {
 158                      $this->tpl_vars[$tpl_var]->value[] = $value;
 159                  }
 160              }
 161          }
 162  
 163          return $this;
 164      }
 165  
 166      /**
 167       * appends values to template variables by reference
 168       *
 169       * @param string $tpl_var the template variable name
 170       * @param mixed  &$value  the referenced value to append
 171       * @param boolean $merge  flag if array elements shall be merged
 172       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 173       */
 174      public function appendByRef($tpl_var, &$value, $merge = false)
 175      {
 176          if ($tpl_var != '' && isset($value)) {
 177              if (!isset($this->tpl_vars[$tpl_var])) {
 178                  $this->tpl_vars[$tpl_var] = new Smarty_variable();
 179              }
 180              if (!is_array($this->tpl_vars[$tpl_var]->value)) {
 181                  settype($this->tpl_vars[$tpl_var]->value, 'array');
 182              }
 183              if ($merge && is_array($value)) {
 184                  foreach($value as $_key => $_val) {
 185                      $this->tpl_vars[$tpl_var]->value[$_key] = &$value[$_key];
 186                  }
 187              } else {
 188                  $this->tpl_vars[$tpl_var]->value[] = &$value;
 189              }
 190          }
 191  
 192          return $this;
 193      }
 194  
 195      /**
 196       * Returns a single or all template variables
 197       *
 198       * @param string  $varname        variable name or null
 199       * @param string  $_ptr           optional pointer to data object
 200       * @param boolean $search_parents include parent templates?
 201       * @return string variable value or or array of variables
 202       */
 203      public function getTemplateVars($varname = null, $_ptr = null, $search_parents = true)
 204      {
 205          if (isset($varname)) {
 206              $_var = $this->getVariable($varname, $_ptr, $search_parents, false);
 207              if (is_object($_var)) {
 208                  return $_var->value;
 209              } else {
 210                  return null;
 211              }
 212          } else {
 213              $_result = array();
 214              if ($_ptr === null) {
 215                  $_ptr = $this;
 216              } while ($_ptr !== null) {
 217                  foreach ($_ptr->tpl_vars AS $key => $var) {
 218                      if (!array_key_exists($key, $_result)) {
 219                          $_result[$key] = $var->value;
 220                      }
 221                  }
 222                  // not found, try at parent
 223                  if ($search_parents) {
 224                      $_ptr = $_ptr->parent;
 225                  } else {
 226                      $_ptr = null;
 227                  }
 228              }
 229              if ($search_parents && isset(Smarty::$global_tpl_vars)) {
 230                  foreach (Smarty::$global_tpl_vars AS $key => $var) {
 231                      if (!array_key_exists($key, $_result)) {
 232                          $_result[$key] = $var->value;
 233                      }
 234                  }
 235              }
 236              return $_result;
 237          }
 238      }
 239  
 240      /**
 241       * clear the given assigned template variable.
 242       *
 243       * @param string|array $tpl_var the template variable(s) to clear
 244       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 245       */
 246      public function clearAssign($tpl_var)
 247      {
 248          if (is_array($tpl_var)) {
 249              foreach ($tpl_var as $curr_var) {
 250                  unset($this->tpl_vars[$curr_var]);
 251              }
 252          } else {
 253              unset($this->tpl_vars[$tpl_var]);
 254          }
 255  
 256          return $this;
 257      }
 258  
 259      /**
 260       * clear all the assigned template variables.
 261       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 262       */
 263      public function clearAllAssign()
 264      {
 265          $this->tpl_vars = array();
 266          return $this;
 267      }
 268  
 269      /**
 270       * load a config file, optionally load just selected sections
 271       *
 272       * @param string $config_file filename
 273       * @param mixed  $sections    array of section names, single section or null
 274       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 275       */
 276      public function configLoad($config_file, $sections = null)
 277      {
 278          // load Config class
 279          $config = new Smarty_Internal_Config($config_file, $this->smarty, $this);
 280          $config->loadConfigVars($sections);
 281          return $this;
 282      }
 283  
 284      /**
 285       * gets the object of a Smarty variable
 286       *
 287       * @param string  $variable the name of the Smarty variable
 288       * @param object  $_ptr     optional pointer to data object
 289       * @param boolean $search_parents search also in parent data
 290       * @return object the object of the variable
 291       */
 292      public function getVariable($variable, $_ptr = null, $search_parents = true, $error_enable = true)
 293      {
 294          if ($_ptr === null) {
 295              $_ptr = $this;
 296          } while ($_ptr !== null) {
 297              if (isset($_ptr->tpl_vars[$variable])) {
 298                  // found it, return it
 299                  return $_ptr->tpl_vars[$variable];
 300              }
 301              // not found, try at parent
 302              if ($search_parents) {
 303                  $_ptr = $_ptr->parent;
 304              } else {
 305                  $_ptr = null;
 306              }
 307          }
 308          if (isset(Smarty::$global_tpl_vars[$variable])) {
 309              // found it, return it
 310              return Smarty::$global_tpl_vars[$variable];
 311          }
 312          if ($this->smarty->error_unassigned && $error_enable) {
 313              // force a notice
 314              $x = $$variable;
 315          }
 316          return new Undefined_Smarty_Variable;
 317      }
 318  
 319      /**
 320       * gets  a config variable
 321       *
 322       * @param string $variable the name of the config variable
 323       * @return mixed the value of the config variable
 324       */
 325      public function getConfigVariable($variable, $error_enable = true)
 326      {
 327          $_ptr = $this;
 328          while ($_ptr !== null) {
 329              if (isset($_ptr->config_vars[$variable])) {
 330                  // found it, return it
 331                  return $_ptr->config_vars[$variable];
 332              }
 333              // not found, try at parent
 334              $_ptr = $_ptr->parent;
 335          }
 336          if ($this->smarty->error_unassigned && $error_enable) {
 337              // force a notice
 338              $x = $$variable;
 339          }
 340          return null;
 341      }
 342  
 343      /**
 344       * gets  a stream variable
 345       *
 346       * @param string $variable the stream of the variable
 347       * @return mixed the value of the stream variable
 348       */
 349      public function getStreamVariable($variable)
 350      {
 351          $_result = '';
 352          $fp = fopen($variable, 'r+');
 353          if ($fp) {
 354              while (!feof($fp) && ($current_line = fgets($fp)) !== false ) {
 355                  $_result .= $current_line;
 356              }
 357              fclose($fp);
 358              return $_result;
 359          }
 360  
 361          if ($this->smarty->error_unassigned) {
 362              throw new SmartyException('Undefined stream variable "' . $variable . '"');
 363          } else {
 364              return null;
 365          }
 366      }
 367  
 368      /**
 369       * Returns a single or all config variables
 370       *
 371       * @param string $varname variable name or null
 372       * @return string variable value or or array of variables
 373       */
 374      public function getConfigVars($varname = null, $search_parents = true)
 375      {
 376          $_ptr = $this;
 377          $var_array = array();
 378          while ($_ptr !== null) {
 379              if (isset($varname)) {
 380                  if (isset($_ptr->config_vars[$varname])) {
 381                      return $_ptr->config_vars[$varname];
 382                  }
 383              } else {
 384                  $var_array = array_merge($_ptr->config_vars, $var_array);
 385              }
 386               // not found, try at parent
 387              if ($search_parents) {
 388                  $_ptr = $_ptr->parent;
 389              } else {
 390                  $_ptr = null;
 391              }
 392          }
 393          if (isset($varname)) {
 394              return '';
 395          } else {
 396              return $var_array;
 397          }
 398      }
 399  
 400      /**
 401       * Deassigns a single or all config variables
 402       *
 403       * @param string $varname variable name or null
 404       * @return Smarty_Internal_Data current Smarty_Internal_Data (or Smarty or Smarty_Internal_Template) instance for chaining
 405       */
 406      public function clearConfig($varname = null)
 407      {
 408          if (isset($varname)) {
 409              unset($this->config_vars[$varname]);
 410          } else {
 411              $this->config_vars = array();
 412          }
 413          return $this;
 414      }
 415  
 416  }
 417  
 418  /**
 419   * class for the Smarty data object
 420   *
 421   * The Smarty data object will hold Smarty variables in the current scope
 422   *
 423   * @package Smarty
 424   * @subpackage Template
 425   */
 426  class Smarty_Data extends Smarty_Internal_Data {
 427  
 428      /**
 429       * Smarty object
 430       *
 431       * @var Smarty
 432       */
 433      public $smarty = null;
 434  
 435      /**
 436       * create Smarty data object
 437       *
 438       * @param Smarty|array $_parent  parent template
 439       * @param Smarty       $smarty   global smarty instance
 440       */
 441      public function __construct ($_parent = null, $smarty = null)
 442      {
 443          $this->smarty = $smarty;
 444          if (is_object($_parent)) {
 445              // when object set up back pointer
 446              $this->parent = $_parent;
 447          } elseif (is_array($_parent)) {
 448              // set up variable values
 449              foreach ($_parent as $_key => $_val) {
 450                  $this->tpl_vars[$_key] = new Smarty_variable($_val);
 451              }
 452          } elseif ($_parent != null) {
 453              throw new SmartyException("Wrong type for template variables");
 454          }
 455      }
 456  
 457  }
 458  
 459  /**
 460   * class for the Smarty variable object
 461   *
 462   * This class defines the Smarty variable object
 463   *
 464   * @package Smarty
 465   * @subpackage Template
 466   */
 467  class Smarty_Variable {
 468  
 469      /**
 470       * template variable
 471       *
 472       * @var mixed
 473       */
 474      public $value = null;
 475      /**
 476       * if true any output of this variable will be not cached
 477       *
 478       * @var boolean
 479       */
 480      public $nocache = false;
 481      /**
 482       * the scope the variable will have  (local,parent or root)
 483       *
 484       * @var int
 485       */
 486      public $scope = Smarty::SCOPE_LOCAL;
 487  
 488      /**
 489       * create Smarty variable object
 490       *
 491       * @param mixed   $value   the value to assign
 492       * @param boolean $nocache if true any output of this variable will be not cached
 493       * @param int     $scope   the scope the variable will have  (local,parent or root)
 494       */
 495      public function __construct($value = null, $nocache = false, $scope = Smarty::SCOPE_LOCAL)
 496      {
 497          $this->value = $value;
 498          $this->nocache = $nocache;
 499          $this->scope = $scope;
 500      }
 501  
 502      /**
 503       * <<magic>> String conversion
 504       *
 505       * @return string
 506       */
 507      public function __toString()
 508      {
 509          return (string) $this->value;
 510      }
 511  
 512  }
 513  
 514  /**
 515   * class for undefined variable object
 516   *
 517   * This class defines an object for undefined variable handling
 518   *
 519   * @package Smarty
 520   * @subpackage Template
 521   */
 522  class Undefined_Smarty_Variable {
 523  
 524      /**
 525       * Returns FALSE for 'nocache' and NULL otherwise.
 526       *
 527       * @param string $name
 528       * @return bool
 529       */
 530      public function __get($name)
 531      {
 532          if ($name == 'nocache') {
 533              return false;
 534          } else {
 535              return null;
 536          }
 537      }
 538  
 539      /**
 540       * Always returns an empty string.
 541       *
 542       * @return string
 543       */
 544      public function __toString()
 545      {
 546          return "";
 547      }
 548  
 549  }
 550  
 551  ?>