Lines Matching refs:nodes
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:
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)
315 isinstance(child, nodes.TemplateData) and child.data.isspace()
317 for child in body.nodes # type: ignore
324 def parse_extends(self) -> nodes.Extends:
325 node = nodes.Extends(lineno=next(self.stream).lineno)
341 def parse_include(self) -> nodes.Include:
342 node = nodes.Include(lineno=next(self.stream).lineno)
353 def parse_import(self) -> nodes.Import:
354 node = nodes.Import(lineno=next(self.stream).lineno)
360 def parse_from(self) -> nodes.FromImport:
361 node = nodes.FromImport(lineno=next(self.stream).lineno)
418 def parse_call_block(self) -> nodes.CallBlock:
419 node = nodes.CallBlock(lineno=next(self.stream).lineno)
427 if not isinstance(call_node, nodes.Call):
433 def parse_filter_block(self) -> nodes.FilterBlock:
434 node = nodes.FilterBlock(lineno=next(self.stream).lineno)
439 def parse_macro(self) -> nodes.Macro:
440 node = nodes.Macro(lineno=next(self.stream).lineno)
446 def parse_print(self) -> nodes.Output:
447 node = nodes.Output(lineno=next(self.stream).lineno)
448 node.nodes = []
450 if node.nodes:
452 node.nodes.append(self.parse_expression())
458 ) -> nodes.Name:
468 ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
477 ) -> t.Union[nodes.NSRef, nodes.Name, nodes.Tuple]:
486 target: nodes.Expr
492 target = nodes.NSRef(token.value, attr.value, lineno=token.lineno)
495 target = nodes.Name(token.value, "store", lineno=token.lineno)
513 def parse_expression(self, with_condexpr: bool = True) -> nodes.Expr:
522 def parse_condexpr(self) -> nodes.Expr:
525 expr3: t.Optional[nodes.Expr]
533 expr1 = nodes.CondExpr(expr2, expr1, expr3, lineno=lineno)
537 def parse_or(self) -> nodes.Expr:
542 left = nodes.Or(left, right, lineno=lineno)
546 def parse_and(self) -> nodes.Expr:
551 left = nodes.And(left, right, lineno=lineno)
555 def parse_not(self) -> nodes.Expr:
558 return nodes.Not(self.parse_not(), lineno=lineno)
561 def parse_compare(self) -> nodes.Expr:
569 ops.append(nodes.Operand(token_type, self.parse_math1()))
571 ops.append(nodes.Operand("in", self.parse_math1()))
576 ops.append(nodes.Operand("notin", self.parse_math1()))
582 return nodes.Compare(expr, ops, lineno=lineno)
584 def parse_math1(self) -> nodes.Expr:
595 def parse_concat(self) -> nodes.Expr:
603 return nodes.Concat(args, lineno=lineno)
605 def parse_math2(self) -> nodes.Expr:
616 def parse_pow(self) -> nodes.Expr:
622 left = nodes.Pow(left, right, lineno=lineno)
626 def parse_unary(self, with_filter: bool = True) -> nodes.Expr:
629 node: nodes.Expr
633 node = nodes.Neg(self.parse_unary(False), lineno=lineno)
636 node = nodes.Pos(self.parse_unary(False), lineno=lineno)
644 def parse_primary(self) -> nodes.Expr:
646 node: nodes.Expr
649 node = nodes.Const(token.value in ("true", "True"), lineno=token.lineno)
651 node = nodes.Const(None, lineno=token.lineno)
653 node = nodes.Name(token.value, "load", lineno=token.lineno)
662 node = nodes.Const("".join(buf), lineno=lineno)
665 node = nodes.Const(token.value, lineno=token.lineno)
684 ) -> t.Union[nodes.Tuple, nodes.Expr]:
710 def parse() -> nodes.Expr:
713 args: t.List[nodes.Expr] = []
742 return nodes.Tuple(args, "load", lineno=lineno)
744 def parse_list(self) -> nodes.List:
746 items: t.List[nodes.Expr] = []
754 return nodes.List(items, lineno=token.lineno)
756 def parse_dict(self) -> nodes.Dict:
758 items: t.List[nodes.Pair] = []
767 items.append(nodes.Pair(key, value, lineno=key.lineno))
769 return nodes.Dict(items, lineno=token.lineno)
771 def parse_postfix(self, node: nodes.Expr) -> nodes.Expr:
784 def parse_filter_expr(self, node: nodes.Expr) -> nodes.Expr:
800 self, node: nodes.Expr
801 ) -> t.Union[nodes.Getattr, nodes.Getitem]:
803 arg: nodes.Expr
809 return nodes.Getattr(
814 arg = nodes.Const(attr_token.value, lineno=attr_token.lineno)
815 return nodes.Getitem(node, arg, "load", lineno=token.lineno)
817 args: t.List[nodes.Expr] = []
826 arg = nodes.Tuple(args, "load", lineno=token.lineno)
827 return nodes.Getitem(node, arg, "load", lineno=token.lineno)
830 def parse_subscribed(self) -> nodes.Expr:
832 args: t.List[t.Optional[nodes.Expr]]
860 return nodes.Slice(lineno=lineno, *args)
900 kwargs.append(nodes.Keyword(key, value, lineno=value.lineno))
911 def parse_call(self, node: nodes.Expr) -> nodes.Call:
916 return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs, lineno=token.lineno)
919 self, node: t.Optional[nodes.Expr], start_inline: bool = False
920 ) -> t.Optional[nodes.Expr]:
935 node = nodes.Filter(
941 def parse_test(self, node: nodes.Expr) -> nodes.Expr:
972 node = nodes.Test(
976 node = nodes.Not(node, lineno=token.lineno)
981 ) -> t.List[nodes.Node]:
982 body: t.List[nodes.Node] = []
983 data_buffer: t.List[nodes.Node] = []
992 body.append(nodes.Output(data_buffer[:], lineno=lineno))
1000 add_data(nodes.TemplateData(token.value, lineno=token.lineno))
1028 def parse(self) -> nodes.Template:
1030 result = nodes.Template(self.subparse(), lineno=1)