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)
{
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)
{
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, ['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)
{
$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)
{
$expression = $parser->parseExpression($stream);
if (!$stream->current()->test(Token::PUNCTUATION, ':')) {
return new PrintNode($expression);
}
return new ExpressionNode($parser->getEnvironment()->getBinaryOperators()->getOperator(':')->createNode($expression, $parser->parseExpression($stream)));
}
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 = $this->helper->createRenderBlockNode($parser->getCurrentBlock(), $this->helper->createContext($stream->next()->test(Token::IDENTIFIER, 'using'), $stream, $parser));
$expression = $node->getChild('expression');
if (!$expression instanceof FunctionNode) {
throw new \UnexpectedValueException("An instance of FunctionNode was expected");
}
$expression->addArgument(new DataNode(true));
return $node;
}
public function createContext($parse, Stream $stream, Parser $parser)
{
if ($parse) {
$contextNode = new FunctionNode('createContext');
$contextNode->addArgument($parser->parseExpression($stream));
$contextNode->setObject(new TempVariableNode('environment'));
} else {
$contextNode = new TempVariableNode('context');
}
return $contextNode;
}
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)
{
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)
{
$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;
}
private function compileTemplate($template)
{
if (!isset($this->compiler)) {
$this->initializeCompiler();
}
$templateSource = $this->getSource($template);
$stream = $this->tokenizer->tokenize($templateSource);
$node = $this->parser->parseTemplate($stream, $template);
$this->nodeTreeTraverser->traverse($node);
return $this->compiler->compile($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;
}
/**
* @param Parser $parser
* @param Stream $stream
* @param $parentTemplate
*
* @return ClassNode
*/
private function parseClass(Parser $parser, Stream $stream, $parentTemplate)
{
$oldClassNode = $parser->getCurrentClassNode();
$fileNode = $parser->getCurrentFileNode();
/** @var $classNode ClassNode */
$classNode = $fileNode->addClass($fileNode->getNextEmbeddedTemplateName());
$classNode->setParentTemplate($parentTemplate);
$parser->setCurrentClassNode($classNode);
$classNode->addChild($parser->parseBlock($stream, 'endembed'), ClassNode::MAIN_TEMPLATE_BLOCK);
$stream->expect(Token::TAG_END);
$parser->setCurrentClassNode($oldClassNode);
return $classNode->getClassName();
}
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)
{
return $this->helper->createRenderFunctionNode($parser->parseExpression($stream), $this->helper->createContext($stream->current()->test(Token::IDENTIFIER, 'using'), $stream, $parser));
}
