public function parse(Parser $parser, Stream $stream)
{
if (!$parser->inMainScope()) {
throw new ParseException("Extends tags must be placed in the main scope. Unexpected extends tag", $stream->current()->getLine());
}
$parser->getCurrentClassNode()->setParentTemplate($parser->parseExpression($stream));
}
public function parse(Parser $parser, Stream $stream)
{
$node = new TagNode($this);
do {
$node->addChild($parser->parseExpression($stream));
} while ($stream->current()->test(Token::PUNCTUATION, ','));
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$stream->expect(Token::IDENTIFIER, 'into');
$node = new TagNode($this);
$node->addChild($parser->parseExpression($stream), 'into');
$node->addChild($parser->parseBlock($stream, 'endcapture'), 'body');
$stream->expect(Token::TAG_END);
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$node = new RootNode();
do {
$left = $parser->parseExpression($stream);
$stream->expectCurrent(Token::PUNCTUATION, ':');
$right = $parser->parseExpression($stream);
$setOperator = $parser->getEnvironment()->getBinaryOperators()->getOperator(':');
$varNode = $setOperator->createNode($left, $right);
$node->addChild(new ExpressionNode($varNode));
} while ($stream->current()->test(Token::PUNCTUATION, ','));
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$templateNameToken = $stream->expect(Token::IDENTIFIER);
$templateName = $templateNameToken->getValue();
$stream->expect(Token::TAG_END);
$classNode = $parser->getCurrentClassNode();
if ($classNode->hasChild($templateName)) {
throw new ParseException("Block {$templateName} is already defined", $templateNameToken->getLine());
}
$parser->enterBlock($templateName);
$parser->getCurrentClassNode()->addChild($parser->parseBlock($stream, 'enddefine'), $templateName);
$stream->expect(Token::TAG_END);
$parser->leaveBlock();
}
public function parse(Parser $parser, Stream $stream)
{
if ($stream->nextTokenIf(Token::IDENTIFIER, 'all')) {
$stream->expect(Token::IDENTIFIER, 'from');
} else {
$blocks = $parser->parseExpression($stream);
$stream->expectCurrent(Token::IDENTIFIER, 'from');
}
$arguments = [$parser->parseExpression($stream)];
if (isset($blocks)) {
$arguments[] = $blocks;
}
return new ExpressionNode($this->helper->createMethodCallNode(new VariableNode('_self'), 'importBlocks', $arguments));
}
public function parse(Parser $parser, Stream $stream)
{
$templateNameToken = $stream->expect(Token::IDENTIFIER);
$templateName = $templateNameToken->getValue();
$stream->expect(Token::TAG_END);
$classNode = $parser->getCurrentClassNode();
if ($classNode->hasChild($templateName)) {
throw new ParseException("Block {$templateName} is already defined", $templateNameToken->getLine());
}
$parser->enterBlock($templateName);
$classNode->addChild($parser->parseBlock($stream, 'endblock'), $templateName);
$stream->expect(Token::TAG_END);
$parser->leaveBlock();
return $this->helper->createRenderBlockNode($templateName, new TempVariableNode('context'));
}
public function parse(Parser $parser, Stream $stream)
{
if ($stream->nextTokenIf(Token::IDENTIFIER)) {
$token = $stream->expectCurrent(Token::IDENTIFIER, ['off', 'on', 'auto', 'disabled', 'enabled']);
} else {
$token = $stream->expect(Token::STRING);
}
switch ($token->getValue()) {
case 'disabled':
case 'off':
$strategy = 0;
break;
case 'on':
case 'enabled':
case 'auto':
$strategy = 1;
break;
default:
$strategy = $token->getValue();
break;
}
$node = new TagNode($this, ['strategy' => $strategy]);
$stream->expect(Token::TAG_END);
$node->addChild($parser->parseBlock($stream, 'endautofilter'), 'body');
$stream->expect(Token::TAG_END);
return $node;
}
private function compareToStackTop(Operator $operator)
{
$top = $this->operatorStack->top();
if ($top === null) {
return false;
}
if ($this->binaryOperators->exists($operator) && $operator === $top) {
if ($operator->isAssociativity(Operator::LEFT)) {
return true;
}
if ($operator->isAssociativity(Operator::RIGHT)) {
return false;
}
//e.g. (5 is divisible by 2 is divisible by 3) is not considered valid
$symbols = $operator->operators();
if (is_array($symbols)) {
$symbols = implode(', ', $symbols);
}
throw new ParseException("Binary operator '{$symbols}' is not associative", $this->stream->current()->getLine());
}
return $top->getPrecedence() >= $operator->getPrecedence();
}
public function parse(Parser $parser, Stream $stream)
{
return $this->helper->createRenderBlockNode($stream->expect(Token::IDENTIFIER)->getValue(), $this->helper->createContext($stream->next()->test(Token::IDENTIFIER, 'using'), $stream, $parser));
}
/**
* @param Stream $stream
*
* @return VariableNode
*/
private function parseVariableNode(Stream $stream)
{
return new VariableNode($stream->expect(Token::VARIABLE)->getValue());
}
public function parseBlock(Stream $stream, $endTags, $type = Token::TAG_START)
{
++$this->level;
$root = new RootNode();
$token = $stream->next();
while (!$token->test($type, $endTags)) {
$token = $this->parseToken($token, $stream, $root);
}
--$this->level;
return $root;
}
