nsz Git - libfirm/blob - scripts/jinja2/compiler.py

   1 # -*- coding: utf-8 -*-
   2 """
   3     jinja2.compiler
   4     ~~~~~~~~~~~~~~~
   5
   6     Compiles nodes into python code.
   7
   8     :copyright: Copyright 2008 by Armin Ronacher.
   9     :license: BSD.
  10 """
  11 from cStringIO import StringIO
  12 from itertools import chain
  13 from jinja2 import nodes
  14 from jinja2.visitor import NodeVisitor, NodeTransformer
  15 from jinja2.exceptions import TemplateAssertionError
  16 from jinja2.utils import Markup, concat, escape, is_python_keyword
  17
  18
  19 operators = {
  20     'eq':       '==',
  21     'ne':       '!=',
  22     'gt':       '>',
  23     'gteq':     '>=',
  24     'lt':       '<',
  25     'lteq':     '<=',
  26     'in':       'in',
  27     'notin':    'not in'
  28 }
  29
  30 try:
  31     exec '(0 if 0 else 0)'
  32 except SyntaxError:
  33     have_condexpr = False
  34 else:
  35     have_condexpr = True
  36
  37
  38 def generate(node, environment, name, filename, stream=None):
  39     """Generate the python source for a node tree."""
  40     if not isinstance(node, nodes.Template):
  41         raise TypeError('Can\'t compile non template nodes')
  42     generator = CodeGenerator(environment, name, filename, stream)
  43     generator.visit(node)
  44     if stream is None:
  45         return generator.stream.getvalue()
  46
  47
  48 def has_safe_repr(value):
  49     """Does the node have a safe representation?"""
  50     if value is None or value is NotImplemented or value is Ellipsis:
  51         return True
  52     if isinstance(value, (bool, int, long, float, complex, basestring,
  53                           xrange, Markup)):
  54         return True
  55     if isinstance(value, (tuple, list, set, frozenset)):
  56         for item in value:
  57             if not has_safe_repr(item):
  58                 return False
  59         return True
  60     elif isinstance(value, dict):
  61         for key, value in value.iteritems():
  62             if not has_safe_repr(key):
  63                 return False
  64             if not has_safe_repr(value):
  65                 return False
  66         return True
  67     return False
  68
  69
  70 def find_undeclared(nodes, names):
  71     """Check if the names passed are accessed undeclared.  The return value
  72     is a set of all the undeclared names from the sequence of names found.
  73     """
  74     visitor = UndeclaredNameVisitor(names)
  75     try:
  76         for node in nodes:
  77             visitor.visit(node)
  78     except VisitorExit:
  79         pass
  80     return visitor.undeclared
  81
  82
  83 class Identifiers(object):
  84     """Tracks the status of identifiers in frames."""
  85
  86     def __init__(self):
  87         # variables that are known to be declared (probably from outer
  88         # frames or because they are special for the frame)
  89         self.declared = set()
  90
  91         # undeclared variables from outer scopes
  92         self.outer_undeclared = set()
  93
  94         # names that are accessed without being explicitly declared by
  95         # this one or any of the outer scopes.  Names can appear both in
  96         # declared and undeclared.
  97         self.undeclared = set()
  98
  99         # names that are declared locally
 100         self.declared_locally = set()
 101
 102         # names that are declared by parameters
 103         self.declared_parameter = set()
 104
 105     def add_special(self, name):
 106         """Register a special name like `loop`."""
 107         self.undeclared.discard(name)
 108         self.declared.add(name)
 109
 110     def is_declared(self, name, local_only=False):
 111         """Check if a name is declared in this or an outer scope."""
 112         if name in self.declared_locally or name in self.declared_parameter:
 113             return True
 114         if local_only:
 115             return False
 116         return name in self.declared
 117
 118     def find_shadowed(self, extra=()):
 119         """Find all the shadowed names.  extra is an iterable of variables
 120         that may be defined with `add_special` which may occour scoped.
 121         """
 122         return (self.declared | self.outer_undeclared) & \
 123                (self.declared_locally | self.declared_parameter) | \
 124                set(x for x in extra if self.is_declared(x))
 125
 126
 127 class Frame(object):
 128     """Holds compile time information for us."""
 129
 130     def __init__(self, parent=None):
 131         self.identifiers = Identifiers()
 132
 133         # a toplevel frame is the root + soft frames such as if conditions.
 134         self.toplevel = False
 135
 136         # the root frame is basically just the outermost frame, so no if
 137         # conditions.  This information is used to optimize inheritance
 138         # situations.
 139         self.rootlevel = False
 140
 141         # in some dynamic inheritance situations the compiler needs to add
 142         # write tests around output statements.
 143         self.require_output_check = parent and parent.require_output_check
 144
 145         # inside some tags we are using a buffer rather than yield statements.
 146         # this for example affects {% filter %} or {% macro %}.  If a frame
 147         # is buffered this variable points to the name of the list used as
 148         # buffer.
 149         self.buffer = None
 150
 151         # the name of the block we're in, otherwise None.
 152         self.block = parent and parent.block or None
 153
 154         # the parent of this frame
 155         self.parent = parent
 156
 157         if parent is not None:
 158             self.identifiers.declared.update(
 159                 parent.identifiers.declared |
 160                 parent.identifiers.declared_locally |
 161                 parent.identifiers.declared_parameter |
 162                 parent.identifiers.undeclared
 163             )
 164             self.identifiers.outer_undeclared.update(
 165                 parent.identifiers.undeclared -
 166                 self.identifiers.declared
 167             )
 168             self.buffer = parent.buffer
 169
 170     def copy(self):
 171         """Create a copy of the current one."""
 172         rv = object.__new__(self.__class__)
 173         rv.__dict__.update(self.__dict__)
 174         rv.identifiers = object.__new__(self.identifiers.__class__)
 175         rv.identifiers.__dict__.update(self.identifiers.__dict__)
 176         return rv
 177
 178     def inspect(self, nodes, hard_scope=False):
 179         """Walk the node and check for identifiers.  If the scope is hard (eg:
 180         enforce on a python level) overrides from outer scopes are tracked
 181         differently.
 182         """
 183         visitor = FrameIdentifierVisitor(self.identifiers, hard_scope)
 184         for node in nodes:
 185             visitor.visit(node)
 186
 187     def inner(self):
 188         """Return an inner frame."""
 189         return Frame(self)
 190
 191     def soft(self):
 192         """Return a soft frame.  A soft frame may not be modified as
 193         standalone thing as it shares the resources with the frame it
 194         was created of, but it's not a rootlevel frame any longer.
 195         """
 196         rv = self.copy()
 197         rv.rootlevel = False
 198         return rv
 199
 200     __copy__ = copy
 201
 202
 203 class VisitorExit(RuntimeError):
 204     """Exception used by the `UndeclaredNameVisitor` to signal a stop."""
 205
 206
 207 class DependencyFinderVisitor(NodeVisitor):
 208     """A visitor that collects filter and test calls."""
 209
 210     def __init__(self):
 211         self.filters = set()
 212         self.tests = set()
 213
 214     def visit_Filter(self, node):
 215         self.generic_visit(node)
 216         self.filters.add(node.name)
 217
 218     def visit_Test(self, node):
 219         self.generic_visit(node)
 220         self.tests.add(node.name)
 221
 222     def visit_Block(self, node):
 223         """Stop visiting at blocks."""
 224
 225
 226 class UndeclaredNameVisitor(NodeVisitor):
 227     """A visitor that checks if a name is accessed without being
 228     declared.  This is different from the frame visitor as it will
 229     not stop at closure frames.
 230     """
 231
 232     def __init__(self, names):
 233         self.names = set(names)
 234         self.undeclared = set()
 235
 236     def visit_Name(self, node):
 237         if node.ctx == 'load' and node.name in self.names:
 238             self.undeclared.add(node.name)
 239             if self.undeclared == self.names:
 240                 raise VisitorExit()
 241         else:
 242             self.names.discard(node.name)
 243
 244     def visit_Block(self, node):
 245         """Stop visiting a blocks."""
 246
 247
 248 class FrameIdentifierVisitor(NodeVisitor):
 249     """A visitor for `Frame.inspect`."""
 250
 251     def __init__(self, identifiers, hard_scope):
 252         self.identifiers = identifiers
 253         self.hard_scope = hard_scope
 254
 255     def visit_Name(self, node):
 256         """All assignments to names go through this function."""
 257         if node.ctx == 'store':
 258             self.identifiers.declared_locally.add(node.name)
 259         elif node.ctx == 'param':
 260             self.identifiers.declared_parameter.add(node.name)
 261         elif node.ctx == 'load' and not \
 262              self.identifiers.is_declared(node.name, self.hard_scope):
 263             self.identifiers.undeclared.add(node.name)
 264
 265     def visit_Macro(self, node):
 266         self.identifiers.declared_locally.add(node.name)
 267
 268     def visit_Import(self, node):
 269         self.generic_visit(node)
 270         self.identifiers.declared_locally.add(node.target)
 271
 272     def visit_FromImport(self, node):
 273         self.generic_visit(node)
 274         for name in node.names:
 275             if isinstance(name, tuple):
 276                 self.identifiers.declared_locally.add(name[1])
 277             else:
 278                 self.identifiers.declared_locally.add(name)
 279
 280     def visit_Assign(self, node):
 281         """Visit assignments in the correct order."""
 282         self.visit(node.node)
 283         self.visit(node.target)
 284
 285     def visit_For(self, node):
 286         """Visiting stops at for blocks.  However the block sequence
 287         is visited as part of the outer scope.
 288         """
 289         self.visit(node.iter)
 290
 291     def visit_CallBlock(self, node):
 292         for child in node.iter_child_nodes(exclude=('body',)):
 293             self.visit(child)
 294
 295     def visit_FilterBlock(self, node):
 296         self.visit(node.filter)
 297
 298     def visit_Block(self, node):
 299         """Stop visiting at blocks."""
 300
 301
 302 class CompilerExit(Exception):
 303     """Raised if the compiler encountered a situation where it just
 304     doesn't make sense to further process the code.  Any block that
 305     raises such an exception is not further processed.
 306     """
 307
 308
 309 class CodeGenerator(NodeVisitor):
 310
 311     def __init__(self, environment, name, filename, stream=None):
 312         if stream is None:
 313             stream = StringIO()
 314         self.environment = environment
 315         self.name = name
 316         self.filename = filename
 317         self.stream = stream
 318
 319         # aliases for imports
 320         self.import_aliases = {}
 321
 322         # a registry for all blocks.  Because blocks are moved out
 323         # into the global python scope they are registered here
 324         self.blocks = {}
 325
 326         # the number of extends statements so far
 327         self.extends_so_far = 0
 328
 329         # some templates have a rootlevel extends.  In this case we
 330         # can safely assume that we're a child template and do some
 331         # more optimizations.
 332         self.has_known_extends = False
 333
 334         # the current line number
 335         self.code_lineno = 1
 336
 337         # registry of all filters and tests (global, not block local)
 338         self.tests = {}
 339         self.filters = {}
 340
 341         # the debug information
 342         self.debug_info = []
 343         self._write_debug_info = None
 344
 345         # the number of new lines before the next write()
 346         self._new_lines = 0
 347
 348         # the line number of the last written statement
 349         self._last_line = 0
 350
 351         # true if nothing was written so far.
 352         self._first_write = True
 353
 354         # used by the `temporary_identifier` method to get new
 355         # unique, temporary identifier
 356         self._last_identifier = 0
 357
 358         # the current indentation
 359         self._indentation = 0
 360
 361     # -- Various compilation helpers
 362
 363     def fail(self, msg, lineno):
 364         """Fail with a `TemplateAssertionError`."""
 365         raise TemplateAssertionError(msg, lineno, self.name, self.filename)
 366
 367     def temporary_identifier(self):
 368         """Get a new unique identifier."""
 369         self._last_identifier += 1
 370         return 't_%d' % self._last_identifier
 371
 372     def buffer(self, frame):
 373         """Enable buffering for the frame from that point onwards."""
 374         frame.buffer = self.temporary_identifier()
 375         self.writeline('%s = []' % frame.buffer)
 376
 377     def return_buffer_contents(self, frame):
 378         """Return the buffer contents of the frame."""
 379         if self.environment.autoescape:
 380             self.writeline('return Markup(concat(%s))' % frame.buffer)
 381         else:
 382             self.writeline('return concat(%s)' % frame.buffer)
 383
 384     def indent(self):
 385         """Indent by one."""
 386         self._indentation += 1
 387
 388     def outdent(self, step=1):
 389         """Outdent by step."""
 390         self._indentation -= step
 391
 392     def start_write(self, frame, node=None):
 393         """Yield or write into the frame buffer."""
 394         if frame.buffer is None:
 395             self.writeline('yield ', node)
 396         else:
 397             self.writeline('%s.append(' % frame.buffer, node)
 398
 399     def end_write(self, frame):
 400         """End the writing process started by `start_write`."""
 401         if frame.buffer is not None:
 402             self.write(')')
 403
 404     def simple_write(self, s, frame, node=None):
 405         """Simple shortcut for start_write + write + end_write."""
 406         self.start_write(frame, node)
 407         self.write(s)
 408         self.end_write(frame)
 409
 410     def blockvisit(self, nodes, frame):
 411         """Visit a list of nodes as block in a frame.  If the current frame
 412         is no buffer a dummy ``if 0: yield None`` is written automatically
 413         unless the force_generator parameter is set to False.
 414         """
 415         if frame.buffer is None:
 416             self.writeline('if 0: yield None')
 417         else:
 418             self.writeline('pass')
 419         try:
 420             for node in nodes:
 421                 self.visit(node, frame)
 422         except CompilerExit:
 423             pass
 424
 425     def write(self, x):
 426         """Write a string into the output stream."""
 427         if self._new_lines:
 428             if not self._first_write:
 429                 self.stream.write('\n' * self._new_lines)
 430                 self.code_lineno += self._new_lines
 431                 if self._write_debug_info is not None:
 432                     self.debug_info.append((self._write_debug_info,
 433                                             self.code_lineno))
 434                     self._write_debug_info = None
 435             self._first_write = False
 436             self.stream.write('    ' * self._indentation)
 437             self._new_lines = 0
 438         self.stream.write(x)
 439
 440     def writeline(self, x, node=None, extra=0):
 441         """Combination of newline and write."""
 442         self.newline(node, extra)
 443         self.write(x)
 444
 445     def newline(self, node=None, extra=0):
 446         """Add one or more newlines before the next write."""
 447         self._new_lines = max(self._new_lines, 1 + extra)
 448         if node is not None and node.lineno != self._last_line:
 449             self._write_debug_info = node.lineno
 450             self._last_line = node.lineno
 451
 452     def signature(self, node, frame, extra_kwargs=None):
 453         """Writes a function call to the stream for the current node.
 454         A leading comma is added automatically.  The extra keyword
 455         arguments may not include python keywords otherwise a syntax
 456         error could occour.  The extra keyword arguments should be given
 457         as python dict.
 458         """
 459         # if any of the given keyword arguments is a python keyword
 460         # we have to make sure that no invalid call is created.
 461         kwarg_workaround = False
 462         for kwarg in chain((x.key for x in node.kwargs), extra_kwargs or ()):
 463             if is_python_keyword(kwarg):
 464                 kwarg_workaround = True
 465                 break
 466
 467         for arg in node.args:
 468             self.write(', ')
 469             self.visit(arg, frame)
 470
 471         if not kwarg_workaround:
 472             for kwarg in node.kwargs:
 473                 self.write(', ')
 474                 self.visit(kwarg, frame)
 475             if extra_kwargs is not None:
 476                 for key, value in extra_kwargs.iteritems():
 477                     self.write(', %s=%s' % (key, value))
 478         if node.dyn_args:
 479             self.write(', *')
 480             self.visit(node.dyn_args, frame)
 481
 482         if kwarg_workaround:
 483             if node.dyn_kwargs is not None:
 484                 self.write(', **dict({')
 485             else:
 486                 self.write(', **{')
 487             for kwarg in node.kwargs:
 488                 self.write('%r: ' % kwarg.key)
 489                 self.visit(kwarg.value, frame)
 490                 self.write(', ')
 491             if extra_kwargs is not None:
 492                 for key, value in extra_kwargs.iteritems():
 493                     self.write('%r: %s, ' % (key, value))
 494             if node.dyn_kwargs is not None:
 495                 self.write('}, **')
 496                 self.visit(node.dyn_kwargs, frame)
 497                 self.write(')')
 498             else:
 499                 self.write('}')
 500
 501         elif node.dyn_kwargs is not None:
 502             self.write(', **')
 503             self.visit(node.dyn_kwargs, frame)
 504
 505     def pull_locals(self, frame):
 506         """Pull all the references identifiers into the local scope."""
 507         for name in frame.identifiers.undeclared:
 508             self.writeline('l_%s = context.resolve(%r)' % (name, name))
 509
 510     def pull_dependencies(self, nodes):
 511         """Pull all the dependencies."""
 512         visitor = DependencyFinderVisitor()
 513         for node in nodes:
 514             visitor.visit(node)
 515         for dependency in 'filters', 'tests':
 516             mapping = getattr(self, dependency)
 517             for name in getattr(visitor, dependency):
 518                 if name not in mapping:
 519                     mapping[name] = self.temporary_identifier()
 520                 self.writeline('%s = environment.%s[%r]' %
 521                                (mapping[name], dependency, name))
 522
 523     def push_scope(self, frame, extra_vars=()):
 524         """This function returns all the shadowed variables in a dict
 525         in the form name: alias and will write the required assignments
 526         into the current scope.  No indentation takes place.
 527
 528         This also predefines locally declared variables from the loop
 529         body because under some circumstances it may be the case that
 530
 531         `extra_vars` is passed to `Identifiers.find_shadowed`.
 532         """
 533         aliases = {}
 534         for name in frame.identifiers.find_shadowed(extra_vars):
 535             aliases[name] = ident = self.temporary_identifier()
 536             self.writeline('%s = l_%s' % (ident, name))
 537         to_declare = set()
 538         for name in frame.identifiers.declared_locally:
 539             if name not in aliases:
 540                 to_declare.add('l_' + name)
 541         if to_declare:
 542             self.writeline(' = '.join(to_declare) + ' = missing')
 543         return aliases
 544
 545     def pop_scope(self, aliases, frame):
 546         """Restore all aliases and delete unused variables."""
 547         for name, alias in aliases.iteritems():
 548             self.writeline('l_%s = %s' % (name, alias))
 549         to_delete = set()
 550         for name in frame.identifiers.declared_locally:
 551             if name not in aliases:
 552                 to_delete.add('l_' + name)
 553         if to_delete:
 554             self.writeline('del ' + ', '.join(to_delete))
 555
 556     def function_scoping(self, node, frame, children=None,
 557                          find_special=True):
 558         """In Jinja a few statements require the help of anonymous
 559         functions.  Those are currently macros and call blocks and in
 560         the future also recursive loops.  As there is currently
 561         technical limitation that doesn't allow reading and writing a
 562         variable in a scope where the initial value is coming from an
 563         outer scope, this function tries to fall back with a common
 564         error message.  Additionally the frame passed is modified so
 565         that the argumetns are collected and callers are looked up.
 566
 567         This will return the modified frame.
 568         """
 569         # we have to iterate twice over it, make sure that works
 570         if children is None:
 571             children = node.iter_child_nodes()
 572         children = list(children)
 573         func_frame = frame.inner()
 574         func_frame.inspect(children, hard_scope=True)
 575
 576         # variables that are undeclared (accessed before declaration) and
 577         # declared locally *and* part of an outside scope raise a template
 578         # assertion error. Reason: we can't generate reasonable code from
 579         # it without aliasing all the variables.  XXX: alias them ^^
 580         overriden_closure_vars = (
 581             func_frame.identifiers.undeclared &
 582             func_frame.identifiers.declared &
 583             (func_frame.identifiers.declared_locally |
 584              func_frame.identifiers.declared_parameter)
 585         )
 586         if overriden_closure_vars:
 587             self.fail('It\'s not possible to set and access variables '
 588                       'derived from an outer scope! (affects: %s' %
 589                       ', '.join(sorted(overriden_closure_vars)), node.lineno)
 590
 591         # remove variables from a closure from the frame's undeclared
 592         # identifiers.
 593         func_frame.identifiers.undeclared -= (
 594             func_frame.identifiers.undeclared &
 595             func_frame.identifiers.declared
 596         )
 597
 598         # no special variables for this scope, abort early
 599         if not find_special:
 600             return func_frame
 601
 602         func_frame.accesses_kwargs = False
 603         func_frame.accesses_varargs = False
 604         func_frame.accesses_caller = False
 605         func_frame.arguments = args = ['l_' + x.name for x in node.args]
 606
 607         undeclared = find_undeclared(children, ('caller', 'kwargs', 'varargs'))
 608
 609         if 'caller' in undeclared:
 610             func_frame.accesses_caller = True
 611             func_frame.identifiers.add_special('caller')
 612             args.append('l_caller')
 613         if 'kwargs' in undeclared:
 614             func_frame.accesses_kwargs = True
 615             func_frame.identifiers.add_special('kwargs')
 616             args.append('l_kwargs')
 617         if 'varargs' in undeclared:
 618             func_frame.accesses_varargs = True
 619             func_frame.identifiers.add_special('varargs')
 620             args.append('l_varargs')
 621         return func_frame
 622
 623     def macro_body(self, node, frame, children=None):
 624         """Dump the function def of a macro or call block."""
 625         frame = self.function_scoping(node, frame, children)
 626         # macros are delayed, they never require output checks
 627         frame.require_output_check = False
 628         args = frame.arguments
 629         self.writeline('def macro(%s):' % ', '.join(args), node)
 630         self.indent()
 631         self.buffer(frame)
 632         self.pull_locals(frame)
 633         self.blockvisit(node.body, frame)
 634         self.return_buffer_contents(frame)
 635         self.outdent()
 636         return frame
 637
 638     def macro_def(self, node, frame):
 639         """Dump the macro definition for the def created by macro_body."""
 640         arg_tuple = ', '.join(repr(x.name) for x in node.args)
 641         name = getattr(node, 'name', None)
 642         if len(node.args) == 1:
 643             arg_tuple += ','
 644         self.write('Macro(environment, macro, %r, (%s), (' %
 645                    (name, arg_tuple))
 646         for arg in node.defaults:
 647             self.visit(arg, frame)
 648             self.write(', ')
 649         self.write('), %r, %r, %r)' % (
 650             bool(frame.accesses_kwargs),
 651             bool(frame.accesses_varargs),
 652             bool(frame.accesses_caller)
 653         ))
 654
 655     def position(self, node):
 656         """Return a human readable position for the node."""
 657         rv = 'line %d' % node.lineno
 658         if self.name is not None:
 659             rv += ' in' + repr(self.name)
 660         return rv
 661
 662     # -- Statement Visitors
 663
 664     def visit_Template(self, node, frame=None):
 665         assert frame is None, 'no root frame allowed'
 666         from jinja2.runtime import __all__ as exported
 667         self.writeline('from __future__ import division')
 668         self.writeline('from jinja2.runtime import ' + ', '.join(exported))
 669
 670         # do we have an extends tag at all?  If not, we can save some
 671         # overhead by just not processing any inheritance code.
 672         have_extends = node.find(nodes.Extends) is not None
 673
 674         # find all blocks
 675         for block in node.find_all(nodes.Block):
 676             if block.name in self.blocks:
 677                 self.fail('block %r defined twice' % block.name, block.lineno)
 678             self.blocks[block.name] = block
 679
 680         # find all imports and import them
 681         for import_ in node.find_all(nodes.ImportedName):
 682             if import_.importname not in self.import_aliases:
 683                 imp = import_.importname
 684                 self.import_aliases[imp] = alias = self.temporary_identifier()
 685                 if '.' in imp:
 686                     module, obj = imp.rsplit('.', 1)
 687                     self.writeline('from %s import %s as %s' %
 688                                    (module, obj, alias))
 689                 else:
 690                     self.writeline('import %s as %s' % (imp, alias))
 691
 692         # add the load name
 693         self.writeline('name = %r' % self.name)
 694
 695         # generate the root render function.
 696         self.writeline('def root(context, environment=environment):', extra=1)
 697
 698         # process the root
 699         frame = Frame()
 700         frame.inspect(node.body)
 701         frame.toplevel = frame.rootlevel = True
 702         frame.require_output_check = have_extends and not self.has_known_extends
 703         self.indent()
 704         if have_extends:
 705             self.writeline('parent_template = None')
 706         if 'self' in find_undeclared(node.body, ('self',)):
 707             frame.identifiers.add_special('self')
 708             self.writeline('l_self = TemplateReference(context)')
 709         self.pull_locals(frame)
 710         self.pull_dependencies(node.body)
 711         self.blockvisit(node.body, frame)
 712         self.outdent()
 713
 714         # make sure that the parent root is called.
 715         if have_extends:
 716             if not self.has_known_extends:
 717                 self.indent()
 718                 self.writeline('if parent_template is not None:')
 719             self.indent()
 720             self.writeline('for event in parent_template.'
 721                            'root_render_func(context):')
 722             self.indent()
 723             self.writeline('yield event')
 724             self.outdent(2 + (not self.has_known_extends))
 725
 726         # at this point we now have the blocks collected and can visit them too.
 727         for name, block in self.blocks.iteritems():
 728             block_frame = Frame()
 729             block_frame.inspect(block.body)
 730             block_frame.block = name
 731             self.writeline('def block_%s(context, environment=environment):'
 732                            % name, block, 1)
 733             self.indent()
 734             undeclared = find_undeclared(block.body, ('self', 'super'))
 735             if 'self' in undeclared:
 736                 block_frame.identifiers.add_special('self')
 737                 self.writeline('l_self = TemplateReference(context)')
 738             if 'super' in undeclared:
 739                 block_frame.identifiers.add_special('super')
 740                 self.writeline('l_super = context.super(%r, '
 741                                'block_%s)' % (name, name))
 742             self.pull_locals(block_frame)
 743             self.pull_dependencies(block.body)
 744             self.blockvisit(block.body, block_frame)
 745             self.outdent()
 746
 747         self.writeline('blocks = {%s}' % ', '.join('%r: block_%s' % (x, x)
 748                                                    for x in self.blocks),
 749                        extra=1)
 750
 751         # add a function that returns the debug info
 752         self.writeline('debug_info = %r' % '&'.join('%s=%s' % x for x
 753                                                     in self.debug_info))
 754
 755     def visit_Block(self, node, frame):
 756         """Call a block and register it for the template."""
 757         level = 1
 758         if frame.toplevel:
 759             # if we know that we are a child template, there is no need to
 760             # check if we are one
 761             if self.has_known_extends:
 762                 return
 763             if self.extends_so_far > 0:
 764                 self.writeline('if parent_template is None:')
 765                 self.indent()
 766                 level += 1
 767         self.writeline('for event in context.blocks[%r][0](context):' %
 768                        node.name, node)
 769         self.indent()
 770         self.simple_write('event', frame)
 771         self.outdent(level)
 772
 773     def visit_Extends(self, node, frame):
 774         """Calls the extender."""
 775         if not frame.toplevel:
 776             self.fail('cannot use extend from a non top-level scope',
 777                       node.lineno)
 778
 779         # if the number of extends statements in general is zero so
 780         # far, we don't have to add a check if something extended
 781         # the template before this one.
 782         if self.extends_so_far > 0:
 783
 784             # if we have a known extends we just add a template runtime
 785             # error into the generated code.  We could catch that at compile
 786             # time too, but i welcome it not to confuse users by throwing the
 787             # same error at different times just "because we can".
 788             if not self.has_known_extends:
 789                 self.writeline('if parent_template is not None:')
 790                 self.indent()
 791             self.writeline('raise TemplateRuntimeError(%r)' %
 792                            'extended multiple times')
 793             self.outdent()
 794
 795             # if we have a known extends already we don't need that code here
 796             # as we know that the template execution will end here.
 797             if self.has_known_extends:
 798                 raise CompilerExit()
 799
 800         self.writeline('parent_template = environment.get_template(', node)
 801         self.visit(node.template, frame)
 802         self.write(', %r)' % self.name)
 803         self.writeline('for name, parent_block in parent_template.'
 804                        'blocks.iteritems():')
 805         self.indent()
 806         self.writeline('context.blocks.setdefault(name, []).'
 807                        'append(parent_block)')
 808         self.outdent()
 809
 810         # if this extends statement was in the root level we can take
 811         # advantage of that information and simplify the generated code
 812         # in the top level from this point onwards
 813         if frame.rootlevel:
 814             self.has_known_extends = True
 815
 816         # and now we have one more
 817         self.extends_so_far += 1
 818
 819     def visit_Include(self, node, frame):
 820         """Handles includes."""
 821         if node.with_context:
 822             self.writeline('template = environment.get_template(', node)
 823             self.visit(node.template, frame)
 824             self.write(', %r)' % self.name)
 825             self.writeline('for event in template.root_render_func('
 826                            'template.new_context(context.parent, True, '
 827                            'locals())):')
 828         else:
 829             self.writeline('for event in environment.get_template(', node)
 830             self.visit(node.template, frame)
 831             self.write(', %r).module._body_stream:' %
 832                        self.name)
 833         self.indent()
 834         self.simple_write('event', frame)
 835         self.outdent()
 836
 837     def visit_Import(self, node, frame):
 838         """Visit regular imports."""
 839         self.writeline('l_%s = ' % node.target, node)
 840         if frame.toplevel:
 841             self.write('context.vars[%r] = ' % node.target)
 842         self.write('environment.get_template(')
 843         self.visit(node.template, frame)
 844         self.write(', %r).' % self.name)
 845         if node.with_context:
 846             self.write('make_module(context.parent, True, locals())')
 847         else:
 848             self.write('module')
 849         if frame.toplevel and not node.target.startswith('_'):
 850             self.writeline('context.exported_vars.discard(%r)' % node.target)
 851
 852     def visit_FromImport(self, node, frame):
 853         """Visit named imports."""
 854         self.newline(node)
 855         self.write('included_template = environment.get_template(')
 856         self.visit(node.template, frame)
 857         self.write(', %r).' % self.name)
 858         if node.with_context:
 859             self.write('make_module(context.parent, True)')
 860         else:
 861             self.write('module')
 862
 863         var_names = []
 864         discarded_names = []
 865         for name in node.names:
 866             if isinstance(name, tuple):
 867                 name, alias = name
 868             else:
 869                 alias = name
 870             self.writeline('l_%s = getattr(included_template, '
 871                            '%r, missing)' % (alias, name))
 872             self.writeline('if l_%s is missing:' % alias)
 873             self.indent()
 874             self.writeline('l_%s = environment.undefined(%r %% '
 875                            'included_template.__name__, '
 876                            'name=%r)' %
 877                            (alias, 'the template %%r (imported on %s) does '
 878                            'not export the requested name %s' % (
 879                                 self.position(node),
 880                                 repr(name)
 881                            ), name))
 882             self.outdent()
 883             if frame.toplevel:
 884                 var_names.append(alias)
 885                 if not alias.startswith('_'):
 886                     discarded_names.append(alias)
 887
 888         if var_names:
 889             if len(var_names) == 1:
 890                 name = var_names[0]
 891                 self.writeline('context.vars[%r] = l_%s' % (name, name))
 892             else:
 893                 self.writeline('context.vars.update({%s})' % ', '.join(
 894                     '%r: l_%s' % (name, name) for name in var_names
 895                 ))
 896         if discarded_names:
 897             if len(discarded_names) == 1:
 898                 self.writeline('context.exported_vars.discard(%r)' %
 899                                discarded_names[0])
 900             else:
 901                 self.writeline('context.exported_vars.difference_'
 902                                'update((%s))' % ', '.join(map(repr, discarded_names)))
 903
 904     def visit_For(self, node, frame):
 905         # when calculating the nodes for the inner frame we have to exclude
 906         # the iterator contents from it
 907         children = node.iter_child_nodes(exclude=('iter',))
 908         if node.recursive:
 909             loop_frame = self.function_scoping(node, frame, children,
 910                                                find_special=False)
 911         else:
 912             loop_frame = frame.inner()
 913             loop_frame.inspect(children)
 914
 915         # try to figure out if we have an extended loop.  An extended loop
 916         # is necessary if the loop is in recursive mode if the special loop
 917         # variable is accessed in the body.
 918         extended_loop = node.recursive or 'loop' in \
 919                         find_undeclared(node.iter_child_nodes(
 920                             only=('body',)), ('loop',))
 921
 922         # if we don't have an recursive loop we have to find the shadowed
 923         # variables at that point.  Because loops can be nested but the loop
 924         # variable is a special one we have to enforce aliasing for it.
 925         if not node.recursive:
 926             aliases = self.push_scope(loop_frame, ('loop',))
 927
 928         # otherwise we set up a buffer and add a function def
 929         else:
 930             self.writeline('def loop(reciter, loop_render_func):', node)
 931             self.indent()
 932             self.buffer(loop_frame)
 933             aliases = {}
 934
 935         # make sure the loop variable is a special one and raise a template
 936         # assertion error if a loop tries to write to loop
 937         if extended_loop:
 938             loop_frame.identifiers.add_special('loop')
 939         for name in node.find_all(nodes.Name):
 940             if name.ctx == 'store' and name.name == 'loop':
 941                 self.fail('Can\'t assign to special loop variable '
 942                           'in for-loop target', name.lineno)
 943
 944         self.pull_locals(loop_frame)
 945         if node.else_:
 946             iteration_indicator = self.temporary_identifier()
 947             self.writeline('%s = 1' % iteration_indicator)
 948
 949         # Create a fake parent loop if the else or test section of a
 950         # loop is accessing the special loop variable and no parent loop
 951         # exists.
 952         if 'loop' not in aliases and 'loop' in find_undeclared(
 953            node.iter_child_nodes(only=('else_', 'test')), ('loop',)):
 954             self.writeline("l_loop = environment.undefined(%r, name='loop')" %
 955                 ("'loop' is undefined. the filter section of a loop as well "
 956                  "as the else block doesn't have access to the special 'loop'"
 957                  " variable of the current loop.  Because there is no parent "
 958                  "loop it's undefined.  Happened in loop on %s" %
 959                  self.position(node)))
 960
 961         self.writeline('for ', node)
 962         self.visit(node.target, loop_frame)
 963         self.write(extended_loop and ', l_loop in LoopContext(' or ' in ')
 964
 965         # if we have an extened loop and a node test, we filter in the
 966         # "outer frame".
 967         if extended_loop and node.test is not None:
 968             self.write('(')
 969             self.visit(node.target, loop_frame)
 970             self.write(' for ')
 971             self.visit(node.target, loop_frame)
 972             self.write(' in ')
 973             if node.recursive:
 974                 self.write('reciter')
 975             else:
 976                 self.visit(node.iter, loop_frame)
 977             self.write(' if (')
 978             test_frame = loop_frame.copy()
 979             self.visit(node.test, test_frame)
 980             self.write('))')
 981
 982         elif node.recursive:
 983             self.write('reciter')
 984         else:
 985             self.visit(node.iter, loop_frame)
 986
 987         if node.recursive:
 988             self.write(', recurse=loop_render_func):')
 989         else:
 990             self.write(extended_loop and '):' or ':')
 991
 992         # tests in not extended loops become a continue
 993         if not extended_loop and node.test is not None:
 994             self.indent()
 995             self.writeline('if not ')
 996             self.visit(node.test, loop_frame)
 997             self.write(':')
 998             self.indent()
 999             self.writeline('continue')
1000             self.outdent(2)
1001
1002         self.indent()
1003         self.blockvisit(node.body, loop_frame)
1004         if node.else_:
1005             self.writeline('%s = 0' % iteration_indicator)
1006         self.outdent()
1007
1008         if node.else_:
1009             self.writeline('if %s:' % iteration_indicator)
1010             self.indent()
1011             self.blockvisit(node.else_, loop_frame)
1012             self.outdent()
1013
1014         # reset the aliases if there are any.
1015         self.pop_scope(aliases, loop_frame)
1016
1017         # if the node was recursive we have to return the buffer contents
1018         # and start the iteration code
1019         if node.recursive:
1020             self.return_buffer_contents(loop_frame)
1021             self.outdent()
1022             self.start_write(frame, node)
1023             self.write('loop(')
1024             self.visit(node.iter, frame)
1025             self.write(', loop)')
1026             self.end_write(frame)
1027
1028     def visit_If(self, node, frame):
1029         if_frame = frame.soft()
1030         self.writeline('if ', node)
1031         self.visit(node.test, if_frame)
1032         self.write(':')
1033         self.indent()
1034         self.blockvisit(node.body, if_frame)
1035         self.outdent()
1036         if node.else_:
1037             self.writeline('else:')
1038             self.indent()
1039             self.blockvisit(node.else_, if_frame)
1040             self.outdent()
1041
1042     def visit_Macro(self, node, frame):
1043         macro_frame = self.macro_body(node, frame)
1044         self.newline()
1045         if frame.toplevel:
1046             if not node.name.startswith('_'):
1047                 self.write('context.exported_vars.add(%r)' % node.name)
1048             self.writeline('context.vars[%r] = ' % node.name)
1049         self.write('l_%s = ' % node.name)
1050         self.macro_def(node, macro_frame)
1051
1052     def visit_CallBlock(self, node, frame):
1053         children = node.iter_child_nodes(exclude=('call',))
1054         call_frame = self.macro_body(node, frame, children)
1055         self.writeline('caller = ')
1056         self.macro_def(node, call_frame)
1057         self.start_write(frame, node)
1058         self.visit_Call(node.call, call_frame, forward_caller=True)
1059         self.end_write(frame)
1060
1061     def visit_FilterBlock(self, node, frame):
1062         filter_frame = frame.inner()
1063         filter_frame.inspect(node.iter_child_nodes())
1064         aliases = self.push_scope(filter_frame)
1065         self.pull_locals(filter_frame)
1066         self.buffer(filter_frame)
1067         self.blockvisit(node.body, filter_frame)
1068         self.start_write(frame, node)
1069         self.visit_Filter(node.filter, filter_frame)
1070         self.end_write(frame)
1071         self.pop_scope(aliases, filter_frame)
1072
1073     def visit_ExprStmt(self, node, frame):
1074         self.newline(node)
1075         self.visit(node.node, frame)
1076
1077     def visit_Output(self, node, frame):
1078         # if we have a known extends statement, we don't output anything
1079         # if we are in a require_output_check section
1080         if self.has_known_extends and frame.require_output_check:
1081             return
1082
1083         if self.environment.finalize:
1084             finalize = lambda x: unicode(self.environment.finalize(x))
1085         else:
1086             finalize = unicode
1087
1088         self.newline(node)
1089
1090         # if we are inside a frame that requires output checking, we do so
1091         outdent_later = False
1092         if frame.require_output_check:
1093             self.writeline('if parent_template is None:')
1094             self.indent()
1095             outdent_later = True
1096
1097         # try to evaluate as many chunks as possible into a static
1098         # string at compile time.
1099         body = []
1100         for child in node.nodes:
1101             try:
1102                 const = child.as_const()
1103             except nodes.Impossible:
1104                 body.append(child)
1105                 continue
1106             try:
1107                 if self.environment.autoescape:
1108                     if hasattr(const, '__html__'):
1109                         const = const.__html__()
1110                     else:
1111                         const = escape(const)
1112                 const = finalize(const)
1113             except:
1114                 # if something goes wrong here we evaluate the node
1115                 # at runtime for easier debugging
1116                 body.append(child)
1117                 continue
1118             if body and isinstance(body[-1], list):
1119                 body[-1].append(const)
1120             else:
1121                 body.append([const])
1122
1123         # if we have less than 3 nodes or a buffer we yield or extend/append
1124         if len(body) < 3 or frame.buffer is not None:
1125             if frame.buffer is not None:
1126                 # for one item we append, for more we extend
1127                 if len(body) == 1:
1128                     self.writeline('%s.append(' % frame.buffer)
1129                 else:
1130                     self.writeline('%s.extend((' % frame.buffer)
1131                 self.indent()
1132             for item in body:
1133                 if isinstance(item, list):
1134                     val = repr(concat(item))
1135                     if frame.buffer is None:
1136                         self.writeline('yield ' + val)
1137                     else:
1138                         self.writeline(val + ', ')
1139                 else:
1140                     if frame.buffer is None:
1141                         self.writeline('yield ', item)
1142                     else:
1143                         self.newline(item)
1144                     close = 1
1145                     if self.environment.autoescape:
1146                         self.write('escape(')
1147                     else:
1148                         self.write('unicode(')
1149                     if self.environment.finalize is not None:
1150                         self.write('environment.finalize(')
1151                         close += 1
1152                     self.visit(item, frame)
1153                     self.write(')' * close)
1154                     if frame.buffer is not None:
1155                         self.write(', ')
1156             if frame.buffer is not None:
1157                 # close the open parentheses
1158                 self.outdent()
1159                 self.writeline(len(body) == 1 and ')' or '))')
1160
1161         # otherwise we create a format string as this is faster in that case
1162         else:
1163             format = []
1164             arguments = []
1165             for item in body:
1166                 if isinstance(item, list):
1167                     format.append(concat(item).replace('%', '%%'))
1168                 else:
1169                     format.append('%s')
1170                     arguments.append(item)
1171             self.writeline('yield ')
1172             self.write(repr(concat(format)) + ' % (')
1173             idx = -1
1174             self.indent()
1175             for argument in arguments:
1176                 self.newline(argument)
1177                 close = 0
1178                 if self.environment.autoescape:
1179                     self.write('escape(')
1180                     close += 1
1181                 if self.environment.finalize is not None:
1182                     self.write('environment.finalize(')
1183                     close += 1
1184                 self.visit(argument, frame)
1185                 self.write(')' * close + ', ')
1186             self.outdent()
1187             self.writeline(')')
1188
1189         if outdent_later:
1190             self.outdent()
1191
1192     def visit_Assign(self, node, frame):
1193         self.newline(node)
1194         # toplevel assignments however go into the local namespace and
1195         # the current template's context.  We create a copy of the frame
1196         # here and add a set so that the Name visitor can add the assigned
1197         # names here.
1198         if frame.toplevel:
1199             assignment_frame = frame.copy()
1200             assignment_frame.assigned_names = set()
1201         else:
1202             assignment_frame = frame
1203         self.visit(node.target, assignment_frame)
1204         self.write(' = ')
1205         self.visit(node.node, frame)
1206
1207         # make sure toplevel assignments are added to the context.
1208         if frame.toplevel:
1209             public_names = [x for x in assignment_frame.assigned_names
1210                             if not x.startswith('_')]
1211             if len(assignment_frame.assigned_names) == 1:
1212                 name = iter(assignment_frame.assigned_names).next()
1213                 self.writeline('context.vars[%r] = l_%s' % (name, name))
1214             else:
1215                 self.writeline('context.vars.update({')
1216                 for idx, name in enumerate(assignment_frame.assigned_names):
1217                     if idx:
1218                         self.write(', ')
1219                     self.write('%r: l_%s' % (name, name))
1220                 self.write('})')
1221             if public_names:
1222                 if len(public_names) == 1:
1223                     self.writeline('context.exported_vars.add(%r)' %
1224                                    public_names[0])
1225                 else:
1226                     self.writeline('context.exported_vars.update((%s))' %
1227                                    ', '.join(map(repr, public_names)))
1228
1229     # -- Expression Visitors
1230
1231     def visit_Name(self, node, frame):
1232         if node.ctx == 'store' and frame.toplevel:
1233             frame.assigned_names.add(node.name)
1234         self.write('l_' + node.name)
1235
1236     def visit_Const(self, node, frame):
1237         val = node.value
1238         if isinstance(val, float):
1239             self.write(str(val))
1240         else:
1241             self.write(repr(val))
1242
1243     def visit_TemplateData(self, node, frame):
1244         self.write(repr(node.as_const()))
1245
1246     def visit_Tuple(self, node, frame):
1247         self.write('(')
1248         idx = -1
1249         for idx, item in enumerate(node.items):
1250             if idx:
1251                 self.write(', ')
1252             self.visit(item, frame)
1253         self.write(idx == 0 and ',)' or ')')
1254
1255     def visit_List(self, node, frame):
1256         self.write('[')
1257         for idx, item in enumerate(node.items):
1258             if idx:
1259                 self.write(', ')
1260             self.visit(item, frame)
1261         self.write(']')
1262
1263     def visit_Dict(self, node, frame):
1264         self.write('{')
1265         for idx, item in enumerate(node.items):
1266             if idx:
1267                 self.write(', ')
1268             self.visit(item.key, frame)
1269             self.write(': ')
1270             self.visit(item.value, frame)
1271         self.write('}')
1272
1273     def binop(operator):
1274         def visitor(self, node, frame):
1275             self.write('(')
1276             self.visit(node.left, frame)
1277             self.write(' %s ' % operator)
1278             self.visit(node.right, frame)
1279             self.write(')')
1280         return visitor
1281
1282     def uaop(operator):
1283         def visitor(self, node, frame):
1284             self.write('(' + operator)
1285             self.visit(node.node, frame)
1286             self.write(')')
1287         return visitor
1288
1289     visit_Add = binop('+')
1290     visit_Sub = binop('-')
1291     visit_Mul = binop('*')
1292     visit_Div = binop('/')
1293     visit_FloorDiv = binop('//')
1294     visit_Pow = binop('**')
1295     visit_Mod = binop('%')
1296     visit_And = binop('and')
1297     visit_Or = binop('or')
1298     visit_Pos = uaop('+')
1299     visit_Neg = uaop('-')
1300     visit_Not = uaop('not ')
1301     del binop, uaop
1302
1303     def visit_Concat(self, node, frame):
1304         self.write('%s((' % (self.environment.autoescape and
1305                              'markup_join' or 'unicode_join'))
1306         for arg in node.nodes:
1307             self.visit(arg, frame)
1308             self.write(', ')
1309         self.write('))')
1310
1311     def visit_Compare(self, node, frame):
1312         self.visit(node.expr, frame)
1313         for op in node.ops:
1314             self.visit(op, frame)
1315
1316     def visit_Operand(self, node, frame):
1317         self.write(' %s ' % operators[node.op])
1318         self.visit(node.expr, frame)
1319
1320     def visit_Getattr(self, node, frame):
1321         self.write('environment.getattr(')
1322         self.visit(node.node, frame)
1323         self.write(', %r)' % node.attr)
1324
1325     def visit_Getitem(self, node, frame):
1326         # slices bypass the environment getitem method.
1327         if isinstance(node.arg, nodes.Slice):
1328             self.visit(node.node, frame)
1329             self.write('[')
1330             self.visit(node.arg, frame)
1331             self.write(']')
1332         else:
1333             self.write('environment.getitem(')
1334             self.visit(node.node, frame)
1335             self.write(', ')
1336             self.visit(node.arg, frame)
1337             self.write(')')
1338
1339     def visit_Slice(self, node, frame):
1340         if node.start is not None:
1341             self.visit(node.start, frame)
1342         self.write(':')
1343         if node.stop is not None:
1344             self.visit(node.stop, frame)
1345         if node.step is not None:
1346             self.write(':')
1347             self.visit(node.step, frame)
1348
1349     def visit_Filter(self, node, frame):
1350         self.write(self.filters[node.name] + '(')
1351         func = self.environment.filters.get(node.name)
1352         if func is None:
1353             self.fail('no filter named %r' % node.name, node.lineno)
1354         if getattr(func, 'contextfilter', False):
1355             self.write('context, ')
1356         elif getattr(func, 'environmentfilter', False):
1357             self.write('environment, ')
1358
1359         # if the filter node is None we are inside a filter block
1360         # and want to write to the current buffer
1361         if node.node is not None:
1362             self.visit(node.node, frame)
1363         elif self.environment.autoescape:
1364             self.write('Markup(concat(%s))' % frame.buffer)
1365         else:
1366             self.write('concat(%s)' % frame.buffer)
1367         self.signature(node, frame)
1368         self.write(')')
1369
1370     def visit_Test(self, node, frame):
1371         self.write(self.tests[node.name] + '(')
1372         if node.name not in self.environment.tests:
1373             self.fail('no test named %r' % node.name, node.lineno)
1374         self.visit(node.node, frame)
1375         self.signature(node, frame)
1376         self.write(')')
1377
1378     def visit_CondExpr(self, node, frame):
1379         def write_expr2():
1380             if node.expr2 is not None:
1381                 return self.visit(node.expr2, frame)
1382             self.write('environment.undefined(%r)' % ('the inline if-'
1383                        'expression on %s evaluated to false and '
1384                        'no else section was defined.' % self.position(node)))
1385
1386         if not have_condexpr:
1387             self.write('((')
1388             self.visit(node.test, frame)
1389             self.write(') and (')
1390             self.visit(node.expr1, frame)
1391             self.write(',) or (')
1392             write_expr2()
1393             self.write(',))[0]')
1394         else:
1395             self.write('(')
1396             self.visit(node.expr1, frame)
1397             self.write(' if ')
1398             self.visit(node.test, frame)
1399             self.write(' else ')
1400             write_expr2()
1401             self.write(')')
1402
1403     def visit_Call(self, node, frame, forward_caller=False):
1404         if self.environment.sandboxed:
1405             self.write('environment.call(context, ')
1406         else:
1407             self.write('context.call(')
1408         self.visit(node.node, frame)
1409         extra_kwargs = forward_caller and {'caller': 'caller'} or None
1410         self.signature(node, frame, extra_kwargs)
1411         self.write(')')
1412
1413     def visit_Keyword(self, node, frame):
1414         self.write(node.key + '=')
1415         self.visit(node.value, frame)
1416
1417     # -- Unused nodes for extensions
1418
1419     def visit_MarkSafe(self, node, frame):
1420         self.write('Markup(')
1421         self.visit(node.expr, frame)
1422         self.write(')')
1423
1424     def visit_EnvironmentAttribute(self, node, frame):
1425         self.write('environment.' + node.name)
1426
1427     def visit_ExtensionAttribute(self, node, frame):
1428         self.write('environment.extensions[%r].%s' % (node.identifier, node.name))
1429
1430     def visit_ImportedName(self, node, frame):
1431         self.write(self.import_aliases[node.importname])
1432
1433     def visit_InternalName(self, node, frame):
1434         self.write(node.name)
1435
1436     def visit_ContextReference(self, node, frame):
1437         self.write('context')
1438
1439     def visit_Continue(self, node, frame):
1440         self.writeline('continue', node)
1441
1442     def visit_Break(self, node, frame):
1443         self.writeline('break', node)