inc/3rdparty/Twig/Extensions/SimpleTokenParser.php

   1 <?php
   2
   3 /*
   4  * This file is part of Twig.
   5  *
   6  * (c) 2010 Fabien Potencier
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11 abstract class Twig_Extensions_SimpleTokenParser extends Twig_TokenParser
  12 {
  13     /**
  14      * Parses a token and returns a node.
  15      *
  16      * @param Twig_Token $token A Twig_Token instance
  17      *
  18      * @return Twig_NodeInterface A Twig_NodeInterface instance
  19      */
  20     public function parse(Twig_Token $token)
  21     {
  22         $grammar = $this->getGrammar();
  23         if (!is_object($grammar)) {
  24             $grammar = self::parseGrammar($grammar);
  25         }
  26
  27         $grammar->setParser($this->parser);
  28         $values = $grammar->parse($token);
  29
  30         return $this->getNode($values, $token->getLine());
  31     }
  32
  33     /**
  34      * Gets the grammar as an object or as a string.
  35      *
  36      * @return string|Twig_Extensions_Grammar A Twig_Extensions_Grammar instance or a string
  37      */
  38     abstract protected function getGrammar();
  39
  40     /**
  41      * Gets the nodes based on the parsed values.
  42      *
  43      * @param array   $values An array of values
  44      * @param integer $line   The parser line
  45      */
  46     abstract protected function getNode(array $values, $line);
  47
  48     protected function getAttribute($node, $attribute, $arguments = array(), $type = Twig_Node_Expression_GetAttr::TYPE_ANY, $line = -1)
  49     {
  50         return new Twig_Node_Expression_GetAttr(
  51             $node instanceof Twig_NodeInterface ? $node : new Twig_Node_Expression_Name($node, $line),
  52             $attribute instanceof Twig_NodeInterface ? $attribute : new Twig_Node_Expression_Constant($attribute, $line),
  53             $arguments instanceof Twig_NodeInterface ? $arguments : new Twig_Node($arguments),
  54             $type,
  55             $line
  56         );
  57     }
  58
  59     protected function call($node, $attribute, $arguments = array(), $line = -1)
  60     {
  61         return $this->getAttribute($node, $attribute, $arguments, Twig_Node_Expression_GetAttr::TYPE_METHOD, $line);
  62     }
  63
  64     protected function markAsSafe(Twig_NodeInterface $node, $line = -1)
  65     {
  66         return new Twig_Node_Expression_Filter(
  67             $node,
  68             new Twig_Node_Expression_Constant('raw', $line),
  69             new Twig_Node(),
  70             $line
  71         );
  72     }
  73
  74     protected function output(Twig_NodeInterface $node, $line = -1)
  75     {
  76         return new Twig_Node_Print($node, $line);
  77     }
  78
  79     protected function getNodeValues(array $values)
  80     {
  81         $nodes = array();
  82         foreach ($values as $value) {
  83             if ($value instanceof Twig_NodeInterface) {
  84                 $nodes[] = $value;
  85             }
  86         }
  87
  88         return $nodes;
  89     }
  90
  91     static public function parseGrammar($str, $main = true)
  92     {
  93         static $cursor;
  94
  95         if (true === $main) {
  96             $cursor = 0;
  97             $grammar = new Twig_Extensions_Grammar_Tag();
  98         } else {
  99             $grammar = new Twig_Extensions_Grammar_Optional();
 100         }
 101
 102         while ($cursor < strlen($str)) {
 103             if (preg_match('/\s+/A', $str, $match, null, $cursor)) {
 104                 $cursor += strlen($match[0]);
 105             } elseif (preg_match('/<(\w+)(?:\:(\w+))?>/A', $str, $match, null, $cursor)) {
 106                 $class = sprintf('Twig_Extensions_Grammar_%s', ucfirst(isset($match[2]) ? $match[2] : 'Expression'));
 107                 if (!class_exists($class)) {
 108                     throw new Twig_Error_Runtime(sprintf('Unable to understand "%s" in grammar (%s class does not exist)', $match[0], $class));
 109                 }
 110                 $grammar->addGrammar(new $class($match[1]));
 111                 $cursor += strlen($match[0]);
 112             } elseif (preg_match('/\w+/A', $str, $match, null, $cursor)) {
 113                 $grammar->addGrammar(new Twig_Extensions_Grammar_Constant($match[0]));
 114                 $cursor += strlen($match[0]);
 115             } elseif (preg_match('/,/A', $str, $match, null, $cursor)) {
 116                 $grammar->addGrammar(new Twig_Extensions_Grammar_Constant($match[0], Twig_Token::PUNCTUATION_TYPE));
 117                 $cursor += strlen($match[0]);
 118             } elseif (preg_match('/\[/A', $str, $match, null, $cursor)) {
 119                 $cursor += strlen($match[0]);
 120                 $grammar->addGrammar(self::parseGrammar($str, false));
 121             } elseif (true !== $main && preg_match('/\]/A', $str, $match, null, $cursor)) {
 122                 $cursor += strlen($match[0]);
 123
 124                 return $grammar;
 125             } else {
 126                 throw new Twig_Error_Runtime(sprintf('Unable to parse grammar "%s" near "...%s..."', $str, substr($str, $cursor, 10)));
 127             }
 128         }
 129
 130         return $grammar;
 131     }
 132 }