Lines Matching refs:node

209         node = result = nodes.If(lineno=self.stream.expect('name:if').lineno)
211             node.test = self.parse_tuple(with_condexpr=False)
212             node.body = self.parse_statements(('name:elif', 'name:else',
214             node.elif_ = []
215             node.else_ = []
218                 node = nodes.If(lineno=self.stream.current.lineno)
219                 result.elif_.append(node)
228         node = nodes.With(lineno=next(self.stream).lineno)
240         node.targets = targets
241         node.values = values
242         node.body = self.parse_statements(('name:endwith',),
244         return node
247         node = nodes.ScopedEvalContextModifier(lineno=next(self.stream).lineno)
248         node.options = [
251         node.body = self.parse_statements(('name:endautoescape',),
253         return nodes.Scope([node])
256         node = nodes.Block(lineno=next(self.stream).lineno)
257         node.name = self.stream.expect('name').value
258         node.scoped = self.stream.skip_if('name:scoped')
268         node.body = self.parse_statements(('name:endblock',), drop_needle=True)
269         self.stream.skip_if('name:' + node.name)
270         return node
273         node = nodes.Extends(lineno=next(self.stream).lineno)
274         node.template = self.parse_expression()
275         return node
277     def parse_import_context(self, node, default):
280             node.with_context = next(self.stream).value == 'with'
283             node.with_context = default
284         return node
287         node = nodes.Include(lineno=next(self.stream).lineno)
288         node.template = self.parse_expression()
291             node.ignore_missing = True
294             node.ignore_missing = False
295         return self.parse_import_context(node, True)
298         node = nodes.Import(lineno=next(self.stream).lineno)
299         node.template = self.parse_expression()
301         node.target = self.parse_assign_target(name_only=True).name
302         return self.parse_import_context(node, False)
305         node = nodes.FromImport(lineno=next(self.stream).lineno)
306         node.template = self.parse_expression()
308         node.names = []
313                 node.with_context = next(self.stream).value == 'with'
319             if node.names:
331                     node.names.append((target.name, alias.name))
333                     node.names.append(target.name)
338         if not hasattr(node, 'with_context'):
339             node.with_context = False
340         return node
342     def parse_signature(self, node):
343         node.args = args = []
344         node.defaults = defaults = []
359         node = nodes.CallBlock(lineno=next(self.stream).lineno)
361             self.parse_signature(node)
363             node.args = []
364             node.defaults = []
366         node.call = self.parse_expression()
367         if not isinstance(node.call, nodes.Call):
368             self.fail('expected call', node.lineno)
369         node.body = self.parse_statements(('name:endcall',), drop_needle=True)
370         return node
373         node = nodes.FilterBlock(lineno=next(self.stream).lineno)
374         node.filter = self.parse_filter(None, start_inline=True)
375         node.body = self.parse_statements(('name:endfilter',),
377         return node
380         node = nodes.Macro(lineno=next(self.stream).lineno)
381         node.name = self.parse_assign_target(name_only=True).name
382         self.parse_signature(node)
383         node.body = self.parse_statements(('name:endmacro',),
385         return node
388         node = nodes.Output(lineno=next(self.stream).lineno)
389         node.nodes = []
391             if node.nodes:
393             node.nodes.append(self.parse_expression())
394         return node
541             node = nodes.Neg(self.parse_unary(False), lineno=lineno)
544             node = nodes.Pos(self.parse_unary(False), lineno=lineno)
546             node = self.parse_primary()
547         node = self.parse_postfix(node)
549             node = self.parse_filter_expr(node)
550         return node
556                 node = nodes.Const(token.value in ('true', 'True'),
559                 node = nodes.Const(None, lineno=token.lineno)
561                 node = nodes.Name(token.value, 'load', lineno=token.lineno)
570             node = nodes.Const(''.join(buf), lineno=lineno)
573             node = nodes.Const(token.value, lineno=token.lineno)
576             node = self.parse_tuple(explicit_parentheses=True)
579             node = self.parse_list()
581             node = self.parse_dict()
584         return node
589         delimited by a comma a :class:`~jinja2.nodes.Tuple` node is created.
668     def parse_postfix(self, node):
672                 node = self.parse_subscript(node)
676                 node = self.parse_call(node)
679         return node
681     def parse_filter_expr(self, node):
685                 node = self.parse_filter(node)
687                 node = self.parse_test(node)
691                 node = self.parse_call(node)
694         return node
696     def parse_subscript(self, node):
702                 return nodes.Getattr(node, attr_token.value, 'load',
707             return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
719             return nodes.Getitem(node, arg, 'load', lineno=token.lineno)
729             node = self.parse_expression()
731                 return node
733             args = [node]
753     def parse_call(self, node):
795         if node is None:
797         return nodes.Call(node, args, kwargs, dyn_args, dyn_kwargs,
800     def parse_filter(self, node, start_inline=False):
815             node = nodes.Filter(node, name, args, kwargs, dyn_args,
818         return node
820     def parse_test(self, node):
845         node = nodes.Test(node, name, args, kwargs, dyn_args,
848             node = nodes.Not(node, lineno=token.lineno)
849         return node
900         """Parse the whole template into a `Template` node."""