[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * Smarty Internal Plugin CompileBase
   4   *
   5   * @package Smarty
   6   * @subpackage Compiler
   7   * @author Uwe Tews
   8   */
   9  
  10  /**
  11   * This class does extend all internal compile plugins
  12   *
  13   * @package Smarty
  14   * @subpackage Compiler
  15   */
  16  abstract class Smarty_Internal_CompileBase {
  17  
  18      /**
  19       * Array of names of required attribute required by tag
  20       *
  21       * @var array
  22       */
  23      public $required_attributes = array();
  24      /**
  25       * Array of names of optional attribute required by tag
  26       * use array('_any') if there is no restriction of attributes names
  27       *
  28       * @var array
  29       */
  30      public $optional_attributes = array();
  31      /**
  32       * Shorttag attribute order defined by its names
  33       *
  34       * @var array
  35       */
  36      public $shorttag_order = array();
  37      /**
  38       * Array of names of valid option flags
  39       *
  40       * @var array
  41       */
  42      public $option_flags = array('nocache');
  43  
  44      /**
  45       * This function checks if the attributes passed are valid
  46       *
  47       * The attributes passed for the tag to compile are checked against the list of required and
  48       * optional attributes. Required attributes must be present. Optional attributes are check against
  49       * the corresponding list. The keyword '_any' specifies that any attribute will be accepted
  50       * as valid
  51       *
  52       * @param object $compiler   compiler object
  53       * @param array  $attributes attributes applied to the tag
  54       * @return array of mapped attributes for further processing
  55       */
  56      public function getAttributes($compiler, $attributes)
  57      {
  58          $_indexed_attr = array();
  59          // loop over attributes
  60          foreach ($attributes as $key => $mixed) {
  61              // shorthand ?
  62              if (!is_array($mixed)) {
  63                  // option flag ?
  64                  if (in_array(trim($mixed, '\'"'), $this->option_flags)) {
  65                      $_indexed_attr[trim($mixed, '\'"')] = true;
  66                      // shorthand attribute ?
  67                  } else if (isset($this->shorttag_order[$key])) {
  68                      $_indexed_attr[$this->shorttag_order[$key]] = $mixed;
  69                  } else {
  70                      // too many shorthands
  71                      $compiler->trigger_template_error('too many shorthand attributes', $compiler->lex->taglineno);
  72                  }
  73                  // named attribute
  74              } else {
  75                  $kv = each($mixed);
  76                  // option flag?
  77                  if (in_array($kv['key'], $this->option_flags)) {
  78                      if (is_bool($kv['value'])) {
  79                          $_indexed_attr[$kv['key']] = $kv['value'];
  80                      } else if (is_string($kv['value']) && in_array(trim($kv['value'], '\'"'), array('true', 'false'))) {
  81                          if (trim($kv['value']) == 'true') {
  82                              $_indexed_attr[$kv['key']] = true;
  83                          } else {
  84                              $_indexed_attr[$kv['key']] = false;
  85                          }
  86                      } else if (is_numeric($kv['value']) && in_array($kv['value'], array(0, 1))) {
  87                          if ($kv['value'] == 1) {
  88                              $_indexed_attr[$kv['key']] = true;
  89                          } else {
  90                              $_indexed_attr[$kv['key']] = false;
  91                          }
  92                      } else {
  93                          $compiler->trigger_template_error("illegal value of option flag \"{$kv['key']}\"", $compiler->lex->taglineno);
  94                      }
  95                      // must be named attribute
  96                  } else {
  97                      reset($mixed);
  98                      $_indexed_attr[key($mixed)] = $mixed[key($mixed)];
  99                  }
 100              }
 101          }
 102          // check if all required attributes present
 103          foreach ($this->required_attributes as $attr) {
 104              if (!array_key_exists($attr, $_indexed_attr)) {
 105                  $compiler->trigger_template_error("missing \"" . $attr . "\" attribute", $compiler->lex->taglineno);
 106              }
 107          }
 108          // check for unallowed attributes
 109          if ($this->optional_attributes != array('_any')) {
 110              $tmp_array = array_merge($this->required_attributes, $this->optional_attributes, $this->option_flags);
 111              foreach ($_indexed_attr as $key => $dummy) {
 112                  if (!in_array($key, $tmp_array) && $key !== 0) {
 113                      $compiler->trigger_template_error("unexpected \"" . $key . "\" attribute", $compiler->lex->taglineno);
 114                  }
 115              }
 116          }
 117          // default 'false' for all option flags not set
 118          foreach ($this->option_flags as $flag) {
 119              if (!isset($_indexed_attr[$flag])) {
 120                  $_indexed_attr[$flag] = false;
 121              }
 122          }
 123  
 124          return $_indexed_attr;
 125      }
 126  
 127      /**
 128       * Push opening tag name on stack
 129       *
 130       * Optionally additional data can be saved on stack
 131       *
 132       * @param object    $compiler   compiler object
 133       * @param string    $openTag    the opening tag's name
 134       * @param mixed     $data       optional data saved
 135       */
 136      public function openTag($compiler, $openTag, $data = null)
 137      {
 138          array_push($compiler->_tag_stack, array($openTag, $data));
 139      }
 140  
 141      /**
 142       * Pop closing tag
 143       *
 144       * Raise an error if this stack-top doesn't match with expected opening tags
 145       *
 146       * @param object       $compiler    compiler object
 147       * @param array|string $expectedTag the expected opening tag names
 148       * @return mixed any type the opening tag's name or saved data
 149       */
 150      public function closeTag($compiler, $expectedTag)
 151      {
 152          if (count($compiler->_tag_stack) > 0) {
 153              // get stacked info
 154              list($_openTag, $_data) = array_pop($compiler->_tag_stack);
 155              // open tag must match with the expected ones
 156              if (in_array($_openTag, (array) $expectedTag)) {
 157                  if (is_null($_data)) {
 158                      // return opening tag
 159                      return $_openTag;
 160                  } else {
 161                      // return restored data
 162                      return $_data;
 163                  }
 164              }
 165              // wrong nesting of tags
 166              $compiler->trigger_template_error("unclosed {" . $_openTag . "} tag");
 167              return;
 168          }
 169          // wrong nesting of tags
 170          $compiler->trigger_template_error("unexpected closing tag", $compiler->lex->taglineno);
 171          return;
 172      }
 173  
 174  }
 175  
 176  ?>