xref: /third_party/jinja2/parser.py

1 """Parse tokens from the lexer into nodes for the compiler."""
5 from . import nodes
15 _ImportInclude = t.TypeVar("_ImportInclude", nodes.Import, nodes.Include)
16 _MacroCall = t.TypeVar("_MacroCall", nodes.Macro, nodes.CallBlock)
36 _math_nodes: t.Dict[str, t.Type[nodes.Expr]] = {
37     "add": nodes.Add,
38     "sub": nodes.Sub,
39     "mul": nodes.Mul,
40     "div": nodes.Div,
41     "floordiv": nodes.FloorDiv,
42     "mod": nodes.Mod,
65             str, t.Callable[["Parser"], t.Union[nodes.Node, t.List[nodes.Node]]]
158     def free_identifier(self, lineno: t.Optional[int] = None) -> nodes.InternalName:
159         """Return a new free identifier as :class:`~jinja2.nodes.InternalName`."""
161         rv = object.__new__(nodes.InternalName)
162         nodes.Node.__init__(rv, f"fi{self._last_identifier}", lineno=lineno)
165     def parse_statement(self) -> t.Union[nodes.Node, t.List[nodes.Node]]:
196     ) -> t.List[nodes.Node]:
223     def parse_set(self) -> t.Union[nodes.Assign, nodes.AssignBlock]:
229             return nodes.Assign(target, expr, lineno=lineno)
232         return nodes.AssignBlock(target, filter_node, body, lineno=lineno)
234     def parse_for(self) -> nodes.For:
251         return nodes.For(target, iter, body, else_, test, recursive, lineno=lineno)
253     def parse_if(self) -> nodes.If:
255         node = result = nodes.If(lineno=self.stream.expect("name:if").lineno)
263                 node = nodes.If(lineno=self.stream.current.lineno)
271     def parse_with(self) -> nodes.With:
272         node = nodes.With(lineno=next(self.stream).lineno)
273         targets: t.List[nodes.Expr] = []
274         values: t.List[nodes.Expr] = []
288     def parse_autoescape(self) -> nodes.Scope:
289         node = nodes.ScopedEvalContextModifier(lineno=next(self.stream).lineno)
290         node.options = [nodes.Keyword("autoescape", self.parse_expression())]
292         return nodes.Scope([node])
294     def parse_block(self) -> nodes.Block:
295         node = nodes.Block(lineno=next(self.stream).lineno)
312         # by asserting that the body, if not empty, is just TemplateData nodes
316                 if not isinstance(body_node, nodes.Output) or any(
317                     not isinstance(output_node, nodes.TemplateData)
319                     for output_node in body_node.nodes
326     def parse_extends(self) -> nodes.Extends:
327         node = nodes.Extends(lineno=next(self.stream).lineno)
343     def parse_include(self) -> nodes.Include:
344         node = nodes.Include(lineno=next(self.stream).lineno)
355     def parse_import(self) -> nodes.Import:
356         node = nodes.Import(lineno=next(self.stream).lineno)
362     def parse_from(self) -> nodes.FromImport:
363         node = nodes.FromImport(lineno=next(self.stream).lineno)
420     def parse_call_block(self) -> nodes.CallBlock:
421         node = nodes.CallBlock(lineno=next(self.stream).lineno)
429         if not isinstance(call_node, nodes.Call):
435     def parse_filter_block(self) -> nodes.FilterBlock:
436         node = nodes.FilterBlock(lineno=next(self.stream).lineno)
441     def parse_macro(self) -> nodes.Macro:
442         node = nodes.Macro(lineno=next(self.stream).lineno)
448     def parse_print(self) -> nodes.Output:
449         node = nodes.Output(lineno=next(self.stream).lineno)
450         node.nodes = []
452             if node.nodes:
454             node.nodes.append(self.parse_expression())
460     ) -> nodes.Name:
470     ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
479     ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
488         target: nodes.Expr
494             target = nodes.NSRef(token.value, attr.value, lineno=token.lineno)
497             target = nodes.Name(token.value, "store", lineno=token.lineno)
515     def parse_expression(self, with_condexpr: bool = True) -> nodes.Expr:
524     def parse_condexpr(self) -> nodes.Expr:
527         expr3: t.Optional[nodes.Expr]
535             expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno)
539     def parse_or(self) -> nodes.Expr:
544             left = nodes.Or(left, right, lineno=lineno)
548     def parse_and(self) -> nodes.Expr:
553             left = nodes.And(left, right, lineno=lineno)
557     def parse_not(self) -> nodes.Expr:
560             return nodes.Not(self.parse_not(), lineno=lineno)
563     def parse_compare(self) -> nodes.Expr:
571                 ops.append(nodes.Operand(token_type, self.parse_math1()))
573                 ops.append(nodes.Operand("in", self.parse_math1()))
578                 ops.append(nodes.Operand("notin", self.parse_math1()))
584         return nodes.Compare(expr, ops, lineno=lineno)
586     def parse_math1(self) -> nodes.Expr:
597     def parse_concat(self) -> nodes.Expr:
605         return nodes.Concat(args, lineno=lineno)
607     def parse_math2(self) -> nodes.Expr:
618     def parse_pow(self) -> nodes.Expr:
624             left = nodes.Pow(left, right, lineno=lineno)
628     def parse_unary(self, with_filter: bool = True) -> nodes.Expr:
631         node: nodes.Expr
635             node = nodes.Neg(self.parse_unary(False), lineno=lineno)
638             node = nodes.Pos(self.parse_unary(False), lineno=lineno)
646     def parse_primary(self) -> nodes.Expr:
648         node: nodes.Expr
651                 node = nodes.Const(token.value in ("true", "True"), lineno=token.lineno)
653                 node = nodes.Const(None, lineno=token.lineno)
655                 node = nodes.Name(token.value, "load", lineno=token.lineno)
664             node = nodes.Const("".join(buf), lineno=lineno)
667             node = nodes.Const(token.value, lineno=token.lineno)
686     ) -> t.Union[nodes.Tuple, nodes.Expr]:
688         delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
712             def parse() -> nodes.Expr:
715         args: t.List[nodes.Expr] = []
744         return nodes.Tuple(args, "load", lineno=lineno)
746     def parse_list(self) -> nodes.List:
748         items: t.List[nodes.Expr] = []
756         return nodes.List(items, lineno=token.lineno)
758     def parse_dict(self) -> nodes.Dict:
760         items: t.List[nodes.Pair] = []
769             items.append(nodes.Pair(key, value, lineno=key.lineno))
771         return nodes.Dict(items, lineno=token.lineno)
773     def parse_postfix(self, node: nodes.Expr) -> nodes.Expr:
786     def parse_filter_expr(self, node: nodes.Expr) -> nodes.Expr:
802         self, node: nodes.Expr
803     ) -> t.Union[nodes.Getattr, nodes.Getitem]:
805         arg: nodes.Expr
811                 return nodes.Getattr(
816             arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
817             return nodes.Getitem(node, arg, "load", lineno=token.lineno)
819             args: t.List[nodes.Expr] = []
828                 arg = nodes.Tuple(args, "load", lineno=token.lineno)
829             return nodes.Getitem(node, arg, "load", lineno=token.lineno)
832     def parse_subscribed(self) -> nodes.Expr:
834         args: t.List[t.Optional[nodes.Expr]]
862         return nodes.Slice(lineno=lineno, *args)  # noqa: B026
902                     kwargs.append(nodes.Keyword(key, value, lineno=value.lineno))
913     def parse_call(self, node: nodes.Expr) -> nodes.Call:
918         return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno)
921         self, node: t.Optional[nodes.Expr], start_inline: bool = False
922     ) -> t.Optional[nodes.Expr]:
937             node = nodes.Filter(
943     def parse_test(self, node: nodes.Expr) -> nodes.Expr:
974         node = nodes.Test(
978             node = nodes.Not(node, lineno=token.lineno)
983     ) -> t.List[nodes.Node]:
984         body: t.List[nodes.Node] = []
985         data_buffer: t.List[nodes.Node] = []
994                 body.append(nodes.Output(data_buffer[:], lineno=lineno))
1002                         add_data(nodes.TemplateData(token.value, lineno=token.lineno))
1030     def parse(self) -> nodes.Template:
1032         result = nodes.Template(self.subparse(), lineno=1)

Indexes created Thu Nov 07 10:32:03 CST 2024