Code
Explorer
You are a developer and looking for Shopware projects?
Apply Now!
parseExpression example
class
IncludeTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$expr
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
list
(
$variables
,
$only
,
$ignoreMissing
)
=
$this
->
parseArguments
(
)
;
return
new
IncludeNode
(
$expr
,
$variables
,
$only
,
$ignoreMissing
,
$token
->
getLine
(
)
,
$this
->
getTag
(
)
)
;
}
protected
function
parseArguments
(
)
{
$stream
=
$this
->parser->
getStream
(
)
;
$ignoreMissing
= false;
protected
$parser
;
public
function
__construct
(
private
readonly TemplateFinder
$finder
)
{
}
/** * @return Node */
public
function
parse
(
Token
$token
)
{
$expr
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
[
$variables
,
$only
,
$ignoreMissing
]
=
$this
->
parseArguments
(
)
;
// resolves parent template
if
(
$expr
->
hasAttribute
(
'value'
)
)
{
// set pointer to next value (contains the template file name)
$parent
=
$this
->finder->
find
(
$expr
->
getAttribute
(
'value'
)
,
$ignoreMissing
)
;
$expr
->
setAttribute
(
'value',
$parent
)
;
return
new
IncludeNode
(
$expr
,
$variables
,
$only
,
$ignoreMissing
,
$token
->
getLine
(
)
,
$this
->
getTag
(
)
)
;
}
$stream
=
$this
->parser->
getStream
(
)
;
if
(
$this
->parser->
peekBlockStack
(
)
)
{
throw
new
SyntaxError
(
'Cannot use "extend" in a block.',
$token
->
getLine
(
)
,
$stream
->
getSourceContext
(
)
)
;
}
elseif
(
!
$this
->parser->
isMainScope
(
)
)
{
throw
new
SyntaxError
(
'Cannot use "extend" in a macro.',
$token
->
getLine
(
)
,
$stream
->
getSourceContext
(
)
)
;
}
if
(
null !==
$this
->parser->
getParent
(
)
)
{
throw
new
SyntaxError
(
'Multiple extends tags are forbidden.',
$token
->
getLine
(
)
,
$stream
->
getSourceContext
(
)
)
;
}
$this
->parser->
setParent
(
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
)
;
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
return
new
Node
(
)
;
}
public
function
getTag
(
)
: string
{
return
'extends';
}
}
final
class
IfTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$lineno
=
$token
->
getLine
(
)
;
$expr
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
$body
=
$this
->parser->
subparse
(
[
$this
, 'decideIfFork'
]
)
;
$tests
=
[
$expr
,
$body
]
;
$else
= null;
$end
= false;
while
(
!
$end
)
{
switch
(
$stream
->
next
(
)
->
getValue
(
)
)
{
case
'else':
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
final
class
FormThemeTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$lineno
=
$token
->
getLine
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$form
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$only
= false;
if
(
$this
->parser->
getStream
(
)
->
test
(
Token::NAME_TYPE, 'with'
)
)
{
$this
->parser->
getStream
(
)
->
next
(
)
;
$resources
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
if
(
$this
->parser->
getStream
(
)
->
nextIf
(
Token::NAME_TYPE, 'only'
)
)
{
$only
= true;
}
}
else
{
$resources
=
new
ArrayExpression
(
[
]
,
$stream
->
getCurrent
(
)
->
getLine
(
)
)
;
/** * Imports macros. * * {% from 'forms.html' import forms %} * * @internal */
final
class
FromTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$macro
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$stream
->
expect
(
/* Token::NAME_TYPE */ 5, 'import'
)
;
$targets
=
[
]
;
do
{
$name
=
$stream
->
expect
(
/* Token::NAME_TYPE */ 5
)
->
getValue
(
)
;
$alias
=
$name
;
if
(
$stream
->
nextIf
(
'as'
)
)
{
$alias
=
$stream
->
expect
(
/* Token::NAME_TYPE */ 5
)
->
getValue
(
)
;
}
while
(
$this
->
isBinary
(
$token
)
&&
$this
->binaryOperators
[
$token
->
getValue
(
)
]
[
'precedence'
]
>=
$precedence
)
{
$op
=
$this
->binaryOperators
[
$token
->
getValue
(
)
]
;
$this
->parser->
getStream
(
)
->
next
(
)
;
if
(
'is not' ===
$token
->
getValue
(
)
)
{
$expr
=
$this
->
parseNotTestExpression
(
$expr
)
;
}
elseif
(
'is' ===
$token
->
getValue
(
)
)
{
$expr
=
$this
->
parseTestExpression
(
$expr
)
;
}
elseif
(
isset
(
$op
[
'callable'
]
)
)
{
$expr
=
$op
[
'callable'
]
(
$this
->parser,
$expr
)
;
}
else
{
$expr1
=
$this
->
parseExpression
(
self::OPERATOR_LEFT ===
$op
[
'associativity'
]
?
$op
[
'precedence'
]
+ 1 :
$op
[
'precedence'
]
, true
)
;
$class
=
$op
[
'class'
]
;
$expr
=
new
$class
(
$expr
,
$expr1
,
$token
->
getLine
(
)
)
;
}
$token
=
$this
->parser->
getCurrentToken
(
)
;
}
if
(
0 ===
$precedence
)
{
return
$this
->
parseConditionalExpression
(
$expr
)
;
}
private
function
getOptions
(
TokenStream
$stream
)
: array
{
if
(
$stream
->
test
(
Token::STRING_TYPE
)
)
{
return
[
'scopes' =>
[
TemplateScopeDetector::DEFAULT_SCOPE
]
,
'template' =>
$stream
->
next
(
)
->
getValue
(
)
,
]
;
}
$expression
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$options
=
$this
->
convertExpressionToArray
(
$expression
)
;
if
(
!
isset
(
$options
[
'template'
]
)
|| !\
is_string
(
$options
[
'template'
]
)
)
{
throw
AdapterException::
missingExtendsTemplate
(
$stream
->
getSourceContext
(
)
->
getName
(
)
)
;
}
if
(
!
isset
(
$options
[
'scopes'
]
)
)
{
$options
[
'scopes'
]
=
[
TemplateScopeDetector::DEFAULT_SCOPE
]
;
}
if
(
\
is_string
(
$options
[
'scopes'
]
)
)
{
public
function
parse
(
Token
$token
)
{
$lineno
=
$token
->
getLine
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$body
= NULL;
$options
= NULL;
$count
= NULL;
$plural
= NULL;
if
(
!
$stream
->
test
(
Token::BLOCK_END_TYPE
)
&&
$stream
->
test
(
Token::STRING_TYPE
)
)
{
$body
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
}
if
(
!
$stream
->
test
(
Token::BLOCK_END_TYPE
)
&&
$stream
->
test
(
Token::NAME_TYPE, 'with'
)
)
{
$stream
->
next
(
)
;
$options
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
}
if
(
!
$body
)
{
$stream
->
expect
(
Token::BLOCK_END_TYPE
)
;
$body
=
$this
->parser->
subparse
(
[
$this
, 'decideForFork'
]
)
;
if
(
'plural' ===
$stream
->
next
(
)
->
getValue
(
)
)
{
$count
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$stream
->
expect
(
Token::BLOCK_END_TYPE
)
;
final
class
WithTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$stream
=
$this
->parser->
getStream
(
)
;
$variables
= null;
$only
= false;
if
(
!
$stream
->
test
(
/* Token::BLOCK_END_TYPE */ 3
)
)
{
$variables
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$only
=
(bool)
$stream
->
nextIf
(
/* Token::NAME_TYPE */ 5, 'only'
)
;
}
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
$body
=
$this
->parser->
subparse
(
[
$this
, 'decideWithEnd'
]
, true
)
;
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
return
new
WithNode
(
$body
,
$variables
,
$only
,
$token
->
getLine
(
)
,
$this
->
getTag
(
)
)
;
}
use
Twig\TokenParser\AbstractTokenParser;
#[Package('core')]
final
class
ReturnNodeTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: ReturnNode
{
$stream
=
$this
->parser->
getStream
(
)
;
$nodes
=
[
]
;
if
(
!
$stream
->
test
(
Token::BLOCK_END_TYPE
)
)
{
$nodes
[
'expr'
]
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
}
$stream
->
expect
(
Token::BLOCK_END_TYPE
)
;
return
new
ReturnNode
(
$nodes
,
[
]
,
$token
->
getLine
(
)
,
$this
->
getTag
(
)
)
;
}
public
function
getTag
(
)
: string
{
return
'return';
}
}
$lineno
=
$this
->
getCurrentToken
(
)
->
getLine
(
)
;
$rv
=
[
]
;
while
(
!
$this
->stream->
isEOF
(
)
)
{
switch
(
$this
->
getCurrentToken
(
)
->
getType
(
)
)
{
case
/* Token::TEXT_TYPE */ 0:
$token
=
$this
->stream->
next
(
)
;
$rv
[
]
=
new
TextNode
(
$token
->
getValue
(
)
,
$token
->
getLine
(
)
)
;
break
;
case
/* Token::VAR_START_TYPE */ 2:
$token
=
$this
->stream->
next
(
)
;
$expr
=
$this
->expressionParser->
parseExpression
(
)
;
$this
->stream->
expect
(
/* Token::VAR_END_TYPE */ 4
)
;
$rv
[
]
=
new
PrintNode
(
$expr
,
$token
->
getLine
(
)
)
;
break
;
case
/* Token::BLOCK_START_TYPE */ 1:
$this
->stream->
next
(
)
;
$token
=
$this
->
getCurrentToken
(
)
;
if
(
/* Token::NAME_TYPE */ 5 !==
$token
->
getType
(
)
)
{
throw
new
SyntaxError
(
'A block must start with a tag name.',
$token
->
getLine
(
)
,
$this
->stream->
getSourceContext
(
)
)
;
}
$lineno
=
$token
->
getLine
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$count
= null;
$vars
=
new
ArrayExpression
(
[
]
,
$lineno
)
;
$domain
= null;
$locale
= null;
if
(
!
$stream
->
test
(
Token::BLOCK_END_TYPE
)
)
{
if
(
$stream
->
test
(
'count'
)
)
{
// {% trans count 5 %}
$stream
->
next
(
)
;
$count
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
}
if
(
$stream
->
test
(
'with'
)
)
{
// {% trans with vars %}
$stream
->
next
(
)
;
$vars
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
}
if
(
$stream
->
test
(
'from'
)
)
{
// {% trans from "messages" %}
$stream
->
next
(
)
;
final
class
ForTokenParser
extends
AbstractTokenParser
{
public
function
parse
(
Token
$token
)
: Node
{
$lineno
=
$token
->
getLine
(
)
;
$stream
=
$this
->parser->
getStream
(
)
;
$targets
=
$this
->parser->
getExpressionParser
(
)
->
parseAssignmentExpression
(
)
;
$stream
->
expect
(
/* Token::OPERATOR_TYPE */ 8, 'in'
)
;
$seq
=
$this
->parser->
getExpressionParser
(
)
->
parseExpression
(
)
;
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
$body
=
$this
->parser->
subparse
(
[
$this
, 'decideForFork'
]
)
;
if
(
'else' ==
$stream
->
next
(
)
->
getValue
(
)
)
{
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
$else
=
$this
->parser->
subparse
(
[
$this
, 'decideForEnd'
]
, true
)
;
}
else
{
$else
= null;
}
$stream
->
expect
(
/* Token::BLOCK_END_TYPE */ 3
)
;
$this
->
doParse
(
$stream
,
$names
)
;
}
/** * @throws SyntaxError */
private
function
doParse
(
TokenStream
$stream
, ?array
$names
=
[
]
)
: Node\Node
{
$this
->stream =
$stream
;
$this
->names =
$names
;
$node
=
$this
->
parseExpression
(
)
;
if
(
!
$stream
->
isEOF
(
)
)
{
throw
new
SyntaxError
(
sprintf
(
'Unexpected token "%s" of value "%s".',
$stream
->current->type,
$stream
->current->value
)
,
$stream
->current->cursor,
$stream
->
getExpression
(
)
)
;
}
unset
(
$this
->stream,
$this
->names
)
;
return
$node
;
}
/** * @return Node\Node */