Lines Matching refs:frame

45         self: "CodeGenerator", node: nodes.Expr, frame: "Frame", **kwargs: t.Any
47 # Only optimize if the frame is not volatile
48 if self.optimizer is not None and not frame.eval_ctx.volatile:
49 new_node = self.optimizer.visit(node, frame.eval_ctx)
52 return self.visit(new_node, frame)
54 return f(self, node, frame, **kwargs)
61 def visitor(self: "CodeGenerator", node: nodes.BinExpr, frame: Frame) -> None:
67 self.visit(node.left, frame)
69 self.visit(node.right, frame)
72 self.visit(node.left, frame)
74 self.visit(node.right, frame)
85 def visitor(self: "CodeGenerator", node: nodes.UnaryExpr, frame: Frame) -> None:
91 self.visit(node.node, frame)
94 self.visit(node.node, frame)
176 # the parent of this frame
187 # this for example affects {% filter %} or {% macro %}. If a frame
201 # a toplevel frame is the root + soft frames such as if conditions.
204 # the root frame is basically just the outermost frame, so no if
214 # track whether the frame is being used in an if-statement or conditional
227 """Return an inner frame."""
233 """Return a soft frame. A soft frame may not be modified as
234 standalone thing as it shares the resources with the frame it
235 was created of, but it's not a rootlevel frame any longer.
273 declared. This is different from the frame visitor as it will
389 def buffer(self, frame: Frame) -> None:
390 """Enable buffering for the frame from that point onwards."""
391 frame.buffer = self.temporary_identifier()
392 self.writeline(f"{frame.buffer} = []")
395 self, frame: Frame, force_unescaped: bool = False
397 """Return the buffer contents of the frame."""
399 if frame.eval_ctx.volatile:
402 self.writeline(f"return Markup(concat({frame.buffer}))")
406 self.writeline(f"return concat({frame.buffer})")
409 elif frame.eval_ctx.autoescape:
410 self.writeline(f"return Markup(concat({frame.buffer}))")
412 self.writeline(f"return concat({frame.buffer})")
422 def start_write(self, frame: Frame, node: t.Optional[nodes.Node] = None) -> None:
423 """Yield or write into the frame buffer."""
424 if frame.buffer is None:
427 self.writeline(f"{frame.buffer}.append(", node)
429 def end_write(self, frame: Frame) -> None:
431 if frame.buffer is not None:
435 self, s: str, frame: Frame, node: t.Optional[nodes.Node] = None
438 self.start_write(frame, node)
440 self.end_write(frame)
442 def blockvisit(self, nodes: t.Iterable[nodes.Node], frame: Frame) -> None:
443 """Visit a list of nodes as block in a frame. If the current frame
449 self.visit(node, frame)
484 frame: Frame,
502 self.visit(arg, frame)
507 self.visit(kwarg, frame)
513 self.visit(node.dyn_args, frame)
522 self.visit(kwarg.value, frame)
529 self.visit(node.dyn_kwargs, frame)
536 self.visit(node.dyn_kwargs, frame)
581 def enter_frame(self, frame: Frame) -> None:
583 for target, (action, param) in frame.symbols.loads.items():
597 def leave_frame(self, frame: Frame, with_python_scope: bool = False) -> None:
600 for target in frame.symbols.loads:
612 self, node: t.Union[nodes.Macro, nodes.CallBlock], frame: Frame
615 frame = frame.inner()
616 frame.symbols.analyze_node(node)
628 args.append(frame.symbols.ref(arg.name))
650 args.append(frame.symbols.declare_parameter("caller"))
653 args.append(frame.symbols.declare_parameter("kwargs"))
656 args.append(frame.symbols.declare_parameter("varargs"))
660 frame.require_output_check = False
661 frame.symbols.analyze_node(node)
665 self.buffer(frame)
666 self.enter_frame(frame)
668 self.push_parameter_definitions(frame)
670 ref = frame.symbols.ref(arg.name)
682 self.visit(default, frame)
687 self.blockvisit(node.body, frame)
688 self.return_buffer_contents(frame, force_unescaped=True)
689 self.leave_frame(frame, with_python_scope=True)
692 return frame, macro_ref
694 def macro_def(self, macro_ref: MacroRef, frame: Frame) -> None:
713 def dump_local_context(self, frame: Frame) -> str:
716 for name, target in frame.symbols.dump_stores().items()
733 def push_parameter_definitions(self, frame: Frame) -> None:
734 """Pushes all parameter targets from the given frame into a local
740 self._param_def_block.append(frame.symbols.dump_param_targets())
768 def derive_context(self, frame: Frame) -> str:
769 return f"{self.get_context_ref()}.derived({self.dump_local_context(frame)})"
781 def pop_assign_tracking(self, frame: Frame) -> None:
787 not frame.block_frame
788 and not frame.loop_frame
789 and not frame.toplevel
796 ref = frame.symbols.ref(name)
797 if frame.loop_frame:
800 if frame.block_frame:
805 if frame.loop_frame:
807 elif frame.block_frame:
814 ref = frame.symbols.ref(name)
817 if not frame.block_frame and not frame.loop_frame and public_names:
827 self, node: nodes.Template, frame: t.Optional[Frame] = None
829 assert frame is None, "no root frame allowed"
877 frame = Frame(eval_ctx)
879 ref = frame.symbols.declare_parameter("self")
881 frame.symbols.analyze_node(node)
882 frame.toplevel = frame.rootlevel = True
883 frame.require_output_check = have_extends and not self.has_known_extends
886 self.enter_frame(frame)
888 self.blockvisit(node.body, frame)
889 self.leave_frame(frame, with_python_scope=True)
918 # It's important that we do not make this frame a child of the
944 def visit_Block(self, node: nodes.Block, frame: Frame) -> None:
947 if frame.toplevel:
958 context = self.derive_context(frame)
971 if not self.environment.is_async and frame.buffer is None:
982 self.simple_write("event", frame)
987 def visit_Extends(self, node: nodes.Extends, frame: Frame) -> None:
989 if not frame.toplevel:
1013 self.visit(node.template, frame)
1023 if frame.rootlevel:
1029 def visit_Include(self, node: nodes.Include, frame: Frame) -> None:
1045 self.visit(node.template, frame)
1061 f" {self.dump_local_context(frame)})):"
1074 self.simple_write("event", frame)
1081 self, node: t.Union[nodes.Import, nodes.FromImport], frame: Frame
1084 self.visit(node.template, frame)
1090 f"{f_name}(context.get_all(), True, {self.dump_local_context(frame)})"
1095 def visit_Import(self, node: nodes.Import, frame: Frame) -> None:
1097 self.writeline(f"{frame.symbols.ref(node.target)} = ", node)
1098 if frame.toplevel:
1101 self._import_common(node, frame)
1103 if frame.toplevel and not node.target.startswith("_"):
1106 def visit_FromImport(self, node: nodes.FromImport, frame: Frame) -> None:
1110 self._import_common(node, frame)
1119 f"{frame.symbols.ref(alias)} ="
1122 self.writeline(f"if {frame.symbols.ref(alias)} is missing:")
1130 f"{frame.symbols.ref(alias)} = undefined(f{message!r}, name={name!r})"
1133 if frame.toplevel:
1141 self.writeline(f"context.vars[{name!r}] = {frame.symbols.ref(name)}")
1144 f"{name!r}: {frame.symbols.ref(name)}" for name in var_names
1156 def visit_For(self, node: nodes.For, frame: Frame) -> None:
1157 loop_frame = frame.inner()
1159 test_frame = frame.inner()
1160 else_frame = frame.inner()
1211 # Use the same buffer for the else frame
1244 self.visit(node.iter, frame)
1280 self.start_write(frame, node)
1284 self.visit(node.iter, frame)
1288 self.end_write(frame)
1295 def visit_If(self, node: nodes.If, frame: Frame) -> None:
1296 if_frame = frame.soft()
1316 def visit_Macro(self, node: nodes.Macro, frame: Frame) -> None:
1317 macro_frame, macro_ref = self.macro_body(node, frame)
1319 if frame.toplevel:
1323 self.write(f"{frame.symbols.ref(node.name)} = ")
1326 def visit_CallBlock(self, node: nodes.CallBlock, frame: Frame) -> None:
1327 call_frame, macro_ref = self.macro_body(node, frame)
1330 self.start_write(frame, node)
1331 self.visit_Call(node.call, frame, forward_caller=True)
1332 self.end_write(frame)
1334 def visit_FilterBlock(self, node: nodes.FilterBlock, frame: Frame) -> None:
1335 filter_frame = frame.inner()
1340 self.start_write(frame, node)
1342 self.end_write(frame)
1345 def visit_With(self, node: nodes.With, frame: Frame) -> None:
1346 with_frame = frame.inner()
1353 self.visit(expr, frame)
1357 def visit_ExprStmt(self, node: nodes.ExprStmt, frame: Frame) -> None:
1359 self.visit(node.node, frame)
1431 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1440 const = node.as_const(frame.eval_ctx)
1442 if frame.eval_ctx.autoescape:
1452 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1457 if frame.eval_ctx.volatile:
1459 elif frame.eval_ctx.autoescape:
1468 self, node: nodes.Expr, frame: Frame, finalize: _FinalizeInfo
1478 def visit_Output(self, node: nodes.Output, frame: Frame) -> None:
1480 if frame.require_output_check:
1506 const = self._output_child_to_const(child, frame, finalize)
1519 if frame.buffer is not None:
1521 self.writeline(f"{frame.buffer}.append(")
1523 self.writeline(f"{frame.buffer}.extend((")
1532 if frame.buffer is None:
1537 if frame.buffer is None:
1543 self._output_child_pre(item, frame, finalize)
1544 self.visit(item, frame)
1545 self._output_child_post(item, frame, finalize)
1547 if frame.buffer is not None:
1550 if frame.buffer is not None:
1554 if frame.require_output_check:
1557 def visit_Assign(self, node: nodes.Assign, frame: Frame) -> None:
1560 self.visit(node.target, frame)
1562 self.visit(node.node, frame)
1563 self.pop_assign_tracking(frame)
1565 def visit_AssignBlock(self, node: nodes.AssignBlock, frame: Frame) -> None:
1567 block_frame = frame.inner()
1577 self.visit(node.target, frame)
1584 self.pop_assign_tracking(frame)
1589 def visit_Name(self, node: nodes.Name, frame: Frame) -> None:
1591 frame.toplevel or frame.loop_frame or frame.block_frame
1595 ref = frame.symbols.ref(node.name)
1601 load = frame.symbols.find_load(ref)
1614 def visit_NSRef(self, node: nodes.NSRef, frame: Frame) -> None:
1618 ref = frame.symbols.ref(node.name)
1628 def visit_Const(self, node: nodes.Const, frame: Frame) -> None:
1629 val = node.as_const(frame.eval_ctx)
1635 def visit_TemplateData(self, node: nodes.TemplateData, frame: Frame) -> None:
1637 self.write(repr(node.as_const(frame.eval_ctx)))
1643 def visit_Tuple(self, node: nodes.Tuple, frame: Frame) -> None:
1649 self.visit(item, frame)
1652 def visit_List(self, node: nodes.List, frame: Frame) -> None:
1657 self.visit(item, frame)
1660 def visit_Dict(self, node: nodes.Dict, frame: Frame) -> None:
1665 self.visit(item.key, frame)
1667 self.visit(item.value, frame)
1684 def visit_Concat(self, node: nodes.Concat, frame: Frame) -> None:
1685 if frame.eval_ctx.volatile:
1687 elif frame.eval_ctx.autoescape:
1693 self.visit(arg, frame)
1698 def visit_Compare(self, node: nodes.Compare, frame: Frame) -> None:
1700 self.visit(node.expr, frame)
1702 self.visit(op, frame)
1705 def visit_Operand(self, node: nodes.Operand, frame: Frame) -> None:
1707 self.visit(node.expr, frame)
1710 def visit_Getattr(self, node: nodes.Getattr, frame: Frame) -> None:
1715 self.visit(node.node, frame)
1722 def visit_Getitem(self, node: nodes.Getitem, frame: Frame) -> None:
1725 self.visit(node.node, frame)
1727 self.visit(node.arg, frame)
1734 self.visit(node.node, frame)
1736 self.visit(node.arg, frame)
1742 def visit_Slice(self, node: nodes.Slice, frame: Frame) -> None:
1744 self.visit(node.start, frame)
1747 self.visit(node.stop, frame)
1750 self.visit(node.step, frame)
1754 self, node: t.Union[nodes.Filter, nodes.Test], frame: Frame, is_filter: bool
1766 # When inside an If or CondExpr frame, allow the filter to be
1769 if func is None and not frame.soft_frame:
1788 self.signature(node, frame)
1795 def visit_Filter(self, node: nodes.Filter, frame: Frame) -> None:
1796 with self._filter_test_common(node, frame, True):
1800 self.visit(node.node, frame)
1801 elif frame.eval_ctx.volatile:
1803 f"(Markup(concat({frame.buffer}))"
1804 f" if context.eval_ctx.autoescape else concat({frame.buffer}))"
1806 elif frame.eval_ctx.autoescape:
1807 self.write(f"Markup(concat({frame.buffer}))")
1809 self.write(f"concat({frame.buffer})")
1812 def visit_Test(self, node: nodes.Test, frame: Frame) -> None:
1813 with self._filter_test_common(node, frame, False):
1814 self.visit(node.node, frame)
1817 def visit_CondExpr(self, node: nodes.CondExpr, frame: Frame) -> None:
1818 frame = frame.soft()
1822 self.visit(node.expr2, frame)
1832 self.visit(node.expr1, frame)
1834 self.visit(node.test, frame)
1841 self, node: nodes.Call, frame: Frame, forward_caller: bool = False
1849 self.visit(node.node, frame)
1851 loop_kwargs = {"_loop_vars": "_loop_vars"} if frame.loop_frame else {}
1852 block_kwargs = {"_block_vars": "_block_vars"} if frame.block_frame else {}
1857 self.signature(node, frame, extra_kwargs)
1862 def visit_Keyword(self, node: nodes.Keyword, frame: Frame) -> None:
1864 self.visit(node.value, frame)
1868 def visit_MarkSafe(self, node: nodes.MarkSafe, frame: Frame) -> None:
1870 self.visit(node.expr, frame)
1874 self, node: nodes.MarkSafeIfAutoescape, frame: Frame
1877 self.visit(node.expr, frame)
1881 self, node: nodes.EnvironmentAttribute, frame: Frame
1886 self, node: nodes.ExtensionAttribute, frame: Frame
1890 def visit_ImportedName(self, node: nodes.ImportedName, frame: Frame) -> None:
1893 def visit_InternalName(self, node: nodes.InternalName, frame: Frame) -> None:
1897 self, node: nodes.ContextReference, frame: Frame
1902 self, node: nodes.DerivedContextReference, frame: Frame
1904 self.write(self.derive_context(frame))
1906 def visit_Continue(self, node: nodes.Continue, frame: Frame) -> None:
1909 def visit_Break(self, node: nodes.Break, frame: Frame) -> None:
1912 def visit_Scope(self, node: nodes.Scope, frame: Frame) -> None:
1913 scope_frame = frame.inner()
1919 def visit_OverlayScope(self, node: nodes.OverlayScope, frame: Frame) -> None:
1921 self.writeline(f"{ctx} = {self.derive_context(frame)}")
1923 self.visit(node.context, frame)
1926 scope_frame = frame.inner(isolated=True)
1934 self, node: nodes.EvalContextModifier, frame: Frame
1938 self.visit(keyword.value, frame)
1940 val = keyword.value.as_const(frame.eval_ctx)
1942 frame.eval_ctx.volatile = True
1944 setattr(frame.eval_ctx, keyword.key, val)
1947 self, node: nodes.ScopedEvalContextModifier, frame: Frame
1950 saved_ctx = frame.eval_ctx.save()
1952 self.visit_EvalContextModifier(node, frame)
1954 self.visit(child, frame)
1955 frame.eval_ctx.revert(saved_ctx)