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)); }