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;
}
public function parse(Parser $parser, Stream $stream)
{
$node = new TagNode($this);
$condition = $parser->parseExpression($stream);
$hasElse = false;
do {
$branchNode = $node->addChild(new RootNode());
if ($condition !== null) {
$branchNode->addChild($condition, 'condition');
}
$body = $parser->parseBlock($stream, ['else', 'elseif', 'endif']);
$branchNode->addChild($body, 'body');
$token = $stream->current();
$tagName = $token->getValue();
if ($tagName === 'else') {
if ($hasElse) {
throw new SyntaxException('If blocks may only contain one else tag', $token->getLine());
}
$condition = null;
$hasElse = true;
$stream->expect(Token::TAG_END);
} elseif ($tagName === 'elseif') {
$condition = $parser->parseExpression($stream);
}
} while ($tagName !== 'endif');
$stream->expect(Token::TAG_END);
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$node = new TagNode($this, ['tested' => $parser->parseExpression($stream)]);
try {
$stream->nextTokenIf(Token::TEXT, 'ctype_space');
$token = $stream->expect(Token::TAG_START, ['case', 'else']);
} catch (SyntaxException $e) {
throw new SyntaxException('Switch expects a case or else tag.', $stream->current()->getLine(), $e);
}
$hasDefault = false;
do {
$branch = $node->addChild(new RootNode());
if ($token->test(Token::TAG_START, 'case')) {
$branch->addChild($parser->parseExpression($stream), 'condition');
} elseif ($token->test(Token::TAG_START, 'else')) {
if ($hasDefault) {
throw new SyntaxException('Switch blocks may only contain one else tag', $token->getLine());
}
$stream->expect(Token::TAG_END);
$hasDefault = true;
}
$body = $parser->parseBlock($stream, ['else', 'case', 'endswitch']);
$branch->addChild($body, 'body');
$token = $stream->current();
} while (!$token->test(Token::TAG_START, 'endswitch'));
$stream->expect(Token::TAG_END);
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)
{
//force the optimizer to compile $environment by always using a temp variable
$environmentNode = new TempVariableNode('environment');
$parentTemplate = $parser->parseExpression($stream);
$contextNode = $this->helper->createContext($stream->current()->test(Token::IDENTIFIER, 'using'), $stream, $parser);
$node = new TagNode($this, ['template' => $this->parseClass($parser, $stream, $parentTemplate)]);
$node->addChild($environmentNode, 'environment');
$node->addChild($contextNode, 'context');
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$environment = $parser->getEnvironment();
$node = new TagNode($environment->getTag('for'), ['save_temp_var' => true, 'create_stack' => true, 'variables' => 1]);
$node->addChild($parser->parseExpression($stream), 'source');
$temp = $node->addChild(new TempVariableNode('element'), 'loop_variable_0');
$loopBody = $node->addChild(new RootNode(), 'loop_body');
if ($stream->current()->test(Token::IDENTIFIER, 'as')) {
$arrayNode = new ArrayNode();
$arrayNode->add($temp, new DataNode($stream->expect(Token::VARIABLE)->getValue()));
$setOperator = $parser->getEnvironment()->getBinaryOperators()->getOperator(':');
$varNode = $setOperator->createNode($temp, $arrayNode);
$loopBody->addChild(new ExpressionNode($varNode));
$stream->next();
}
$stream->expectCurrent(Token::IDENTIFIER, 'using');
$loopBody->addChild($this->helper->createRenderFunctionNode($parser->parseExpression($stream), $temp));
return $node;
}
public function parse(Parser $parser, Stream $stream)
{
$node = new TagNode($this);
$loopVar = $this->parseVariableNode($stream);
if ($stream->nextTokenIf(Token::PUNCTUATION, [':', '=>'])) {
$node->addChild($loopVar, 'loop_key');
$loopVar = $this->parseVariableNode($stream);
}
$node->addChild($loopVar, 'loop_variable_0');
$i = 1;
while ($stream->nextTokenIf(Token::PUNCTUATION, ',')) {
$node->addChild($this->parseVariableNode($stream), 'loop_variable_' . $i++);
}
$node->addData('variables', $i);
$stream->expect(Token::OPERATOR, 'in');
$node->addChild($parser->parseExpression($stream), 'source');
$node->addChild($parser->parseBlock($stream, ['else', 'endfor']), 'loop_body');
if ($stream->next()->test(Token::TAG_END, 'else')) {
$node->addChild($parser->parseBlock($stream, 'endfor'), 'else');
$stream->expect(Token::TAG_END);
}
return $node;
}
public function compile(Compiler $compiler, TagNode $node)
{
$compiler->indented('unset')->compileArgumentList($node->getChildren())->add(';');
}
