diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8afb23b..cecefd8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -12,15 +12,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: 'Build'
-        run: |
-          docker run \
-            --user $(id -u):$(id -g) \
-            -v "/var/run/docker.sock":"/var/run/docker.sock" \
-            -v ${{ github.workspace }}:/work \
-            -w /work \
-            --entrypoint bash \
-            python:2.7.18 \
-            -c /work/render.sh
+        run: ./render.sh
       - name: 'Deploy'
         if: ${{ (github.repository == 'jacoco/www.eclemma.org' && github.ref == 'refs/heads/master') }}
         env:
diff --git a/generator/eclemmasite.py b/generator/eclemmasite.py
index bbe3c76..0439955 100644
--- a/generator/eclemmasite.py
+++ b/generator/eclemmasite.py
@@ -1,7 +1,4 @@
-"""EclEmma's site structure at SourceForge
-
-$LastChangedDate$
-$Revision$
+"""EclEmma's web site structure
 """
 
 import sys
diff --git a/generator/genshi/__init__.py b/generator/genshi/__init__.py
deleted file mode 100644
index 50e01ce..0000000
--- a/generator/genshi/__init__.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""This package provides various means for generating and processing web markup
-(XML or HTML).
-
-The design is centered around the concept of streams of markup events (similar
-in concept to SAX parsing events) which can be processed in a uniform manner
-independently of where or how they are produced.
-"""
-
-__docformat__ = 'restructuredtext en'
-#try:
-#    __version__ = __import__('pkg_resources').get_distribution('Genshi').version
-#except ImportError:
-#    pass
-
-from genshi.core import *
-from genshi.input import ParseError, XML, HTML
diff --git a/generator/genshi/builder.py b/generator/genshi/builder.py
deleted file mode 100644
index 38ca3f9..0000000
--- a/generator/genshi/builder.py
+++ /dev/null
@@ -1,338 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Support for programmatically generating markup streams from Python code using
-a very simple syntax. The main entry point to this module is the `tag` object
-(which is actually an instance of the ``ElementFactory`` class). You should
-rarely (if ever) need to directly import and use any of the other classes in
-this module.
-
-Elements can be created using the `tag` object using attribute access. For
-example:
-
->>> doc = tag.p('Some text and ', tag.a('a link', href='http://example.org/'), '.')
->>> doc
-<Element "p">
-
-This produces an `Element` instance which can be further modified to add child
-nodes and attributes. This is done by "calling" the element: positional
-arguments are added as child nodes (alternatively, the `Element.append` method
-can be used for that purpose), whereas keywords arguments are added as
-attributes:
-
->>> doc(tag.br)
-<Element "p">
->>> print doc
-<p>Some text and <a href="http://example.org/">a link</a>.<br/></p>
-
-If an attribute name collides with a Python keyword, simply append an underscore
-to the name:
-
->>> doc(class_='intro')
-<Element "p">
->>> print doc
-<p class="intro">Some text and <a href="http://example.org/">a link</a>.<br/></p>
-
-As shown above, an `Element` can easily be directly rendered to XML text by
-printing it or using the Python ``str()`` function. This is basically a
-shortcut for converting the `Element` to a stream and serializing that
-stream:
-
->>> stream = doc.generate()
->>> stream #doctest: +ELLIPSIS
-<genshi.core.Stream object at ...>
->>> print stream
-<p class="intro">Some text and <a href="http://example.org/">a link</a>.<br/></p>
-
-
-The `tag` object also allows creating "fragments", which are basically lists
-of nodes (elements or text) that don't have a parent element. This can be useful
-for creating snippets of markup that are attached to a parent element later (for
-example in a template). Fragments are created by calling the `tag` object, which
-returns an object of type `Fragment`:
-
->>> fragment = tag('Hello, ', tag.em('world'), '!')
->>> fragment
-<Fragment>
->>> print fragment
-Hello, <em>world</em>!
-"""
-
-from genshi.core import Attrs, Namespace, QName, Stream, START, END, TEXT
-
-__all__ = ['Fragment', 'Element', 'ElementFactory', 'tag']
-__docformat__ = 'restructuredtext en'
-
-
-class Fragment(object):
-    """Represents a markup fragment, which is basically just a list of element
-    or text nodes.
-    """
-    __slots__ = ['children']
-
-    def __init__(self):
-        """Create a new fragment."""
-        self.children = []
-
-    def __add__(self, other):
-        return Fragment()(self, other)
-
-    def __call__(self, *args):
-        """Append any positional arguments as child nodes.
-        
-        :see: `append`
-        """
-        map(self.append, args)
-        return self
-
-    def __iter__(self):
-        return self._generate()
-
-    def __repr__(self):
-        return '<%s>' % self.__class__.__name__
-
-    def __str__(self):
-        return str(self.generate())
-
-    def __unicode__(self):
-        return unicode(self.generate())
-
-    def append(self, node):
-        """Append an element or string as child node.
-        
-        :param node: the node to append; can be an `Element`, `Fragment`, or a
-                     `Stream`, or a Python string or number
-        """
-        if isinstance(node, (Stream, Element, basestring, int, float, long)):
-            # For objects of a known/primitive type, we avoid the check for
-            # whether it is iterable for better performance
-            self.children.append(node)
-        elif isinstance(node, Fragment):
-            self.children.extend(node.children)
-        elif node is not None:
-            try:
-                map(self.append, iter(node))
-            except TypeError:
-                self.children.append(node)
-
-    def _generate(self):
-        for child in self.children:
-            if isinstance(child, Fragment):
-                for event in child._generate():
-                    yield event
-            elif isinstance(child, Stream):
-                for event in child:
-                    yield event
-            else:
-                if not isinstance(child, basestring):
-                    child = unicode(child)
-                yield TEXT, child, (None, -1, -1)
-
-    def generate(self):
-        """Return a markup event stream for the fragment."""
-        return Stream(self._generate())
-
-
-def _value_to_unicode(value):
-    if isinstance(value, unicode):
-        return value
-    return unicode(value)
-
-def _kwargs_to_attrs(kwargs):
-    return [(QName(k.rstrip('_').replace('_', '-')), _value_to_unicode(v))
-            for k, v in kwargs.items() if v is not None]
-
-
-class Element(Fragment):
-    """Simple XML output generator based on the builder pattern.
-
-    Construct XML elements by passing the tag name to the constructor:
-
-    >>> print Element('strong')
-    <strong/>
-
-    Attributes can be specified using keyword arguments. The values of the
-    arguments will be converted to strings and any special XML characters
-    escaped:
-
-    >>> print Element('textarea', rows=10, cols=60)
-    <textarea rows="10" cols="60"/>
-    >>> print Element('span', title='1 < 2')
-    <span title="1 &lt; 2"/>
-    >>> print Element('span', title='"baz"')
-    <span title="&#34;baz&#34;"/>
-
-    The " character is escaped using a numerical entity.
-    The order in which attributes are rendered is undefined.
-
-    If an attribute value evaluates to `None`, that attribute is not included
-    in the output:
-
-    >>> print Element('a', name=None)
-    <a/>
-
-    Attribute names that conflict with Python keywords can be specified by
-    appending an underscore:
-
-    >>> print Element('div', class_='warning')
-    <div class="warning"/>
-
-    Nested elements can be added to an element using item access notation.
-    The call notation can also be used for this and for adding attributes
-    using keyword arguments, as one would do in the constructor.
-
-    >>> print Element('ul')(Element('li'), Element('li'))
-    <ul><li/><li/></ul>
-    >>> print Element('a')('Label')
-    <a>Label</a>
-    >>> print Element('a')('Label', href="target")
-    <a href="target">Label</a>
-
-    Text nodes can be nested in an element by adding strings instead of
-    elements. Any special characters in the strings are escaped automatically:
-
-    >>> print Element('em')('Hello world')
-    <em>Hello world</em>
-    >>> print Element('em')(42)
-    <em>42</em>
-    >>> print Element('em')('1 < 2')
-    <em>1 &lt; 2</em>
-
-    This technique also allows mixed content:
-
-    >>> print Element('p')('Hello ', Element('b')('world'))
-    <p>Hello <b>world</b></p>
-
-    Quotes are not escaped inside text nodes:
-    >>> print Element('p')('"Hello"')
-    <p>"Hello"</p>
-
-    Elements can also be combined with other elements or strings using the
-    addition operator, which results in a `Fragment` object that contains the
-    operands:
-    
-    >>> print Element('br') + 'some text' + Element('br')
-    <br/>some text<br/>
-    
-    Elements with a namespace can be generated using the `Namespace` and/or
-    `QName` classes:
-    
-    >>> from genshi.core import Namespace
-    >>> xhtml = Namespace('http://www.w3.org/1999/xhtml')
-    >>> print Element(xhtml.html, lang='en')
-    <html xmlns="http://www.w3.org/1999/xhtml" lang="en"/>
-    """
-    __slots__ = ['tag', 'attrib']
-
-    def __init__(self, tag_, **attrib):
-        Fragment.__init__(self)
-        self.tag = QName(tag_)
-        self.attrib = Attrs(_kwargs_to_attrs(attrib))
-
-    def __call__(self, *args, **kwargs):
-        """Append any positional arguments as child nodes, and keyword arguments
-        as attributes.
-        
-        :see: `Fragment.append`
-        """
-        self.attrib |= Attrs(_kwargs_to_attrs(kwargs))
-        Fragment.__call__(self, *args)
-        return self
-
-    def __repr__(self):
-        return '<%s "%s">' % (self.__class__.__name__, self.tag)
-
-    def _generate(self):
-        yield START, (self.tag, self.attrib), (None, -1, -1)
-        for kind, data, pos in Fragment._generate(self):
-            yield kind, data, pos
-        yield END, self.tag, (None, -1, -1)
-
-    def generate(self):
-        """Return a markup event stream for the fragment."""
-        return Stream(self._generate())
-
-
-class ElementFactory(object):
-    """Factory for `Element` objects.
-    
-    A new element is created simply by accessing a correspondingly named
-    attribute of the factory object:
-    
-    >>> factory = ElementFactory()
-    >>> print factory.foo
-    <foo/>
-    >>> print factory.foo(id=2)
-    <foo id="2"/>
-    
-    Markup fragments (lists of nodes without a parent element) can be created
-    by calling the factory:
-    
-    >>> print factory('Hello, ', factory.em('world'), '!')
-    Hello, <em>world</em>!
-    
-    A factory can also be bound to a specific namespace:
-    
-    >>> factory = ElementFactory('http://www.w3.org/1999/xhtml')
-    >>> print factory.html(lang="en")
-    <html xmlns="http://www.w3.org/1999/xhtml" lang="en"/>
-    
-    The namespace for a specific element can be altered on an existing factory
-    by specifying the new namespace using item access:
-    
-    >>> factory = ElementFactory()
-    >>> print factory.html(factory['http://www.w3.org/2000/svg'].g(id=3))
-    <html><g xmlns="http://www.w3.org/2000/svg" id="3"/></html>
-    
-    Usually, the `ElementFactory` class is not be used directly. Rather, the
-    `tag` instance should be used to create elements.
-    """
-
-    def __init__(self, namespace=None):
-        """Create the factory, optionally bound to the given namespace.
-        
-        :param namespace: the namespace URI for any created elements, or `None`
-                          for no namespace
-        """
-        if namespace and not isinstance(namespace, Namespace):
-            namespace = Namespace(namespace)
-        self.namespace = namespace
-
-    def __call__(self, *args):
-        """Create a fragment that has the given positional arguments as child
-        nodes.
-
-        :return: the created `Fragment`
-        """
-        return Fragment()(*args)
-
-    def __getitem__(self, namespace):
-        """Return a new factory that is bound to the specified namespace.
-        
-        :param namespace: the namespace URI or `Namespace` object
-        :return: an `ElementFactory` that produces elements bound to the given
-                 namespace
-        """
-        return ElementFactory(namespace)
-
-    def __getattr__(self, name):
-        """Create an `Element` with the given name.
-        
-        :param name: the tag name of the element to create
-        :return: an `Element` with the specified name
-        """
-        return Element(self.namespace and self.namespace[name] or name)
-
-
-tag = ElementFactory()
-"""Global `ElementFactory` bound to the default namespace."""
diff --git a/generator/genshi/core.py b/generator/genshi/core.py
deleted file mode 100644
index 94c606d..0000000
--- a/generator/genshi/core.py
+++ /dev/null
@@ -1,606 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Core classes for markup processing."""
-
-import operator
-
-from genshi.util import plaintext, stripentities, striptags
-
-__all__ = ['Stream', 'Markup', 'escape', 'unescape', 'Attrs', 'Namespace',
-           'QName']
-__docformat__ = 'restructuredtext en'
-
-
-class StreamEventKind(str):
-    """A kind of event on a markup stream."""
-    __slots__ = []
-    _instances = {}
-
-    def __new__(cls, val):
-        return cls._instances.setdefault(val, str.__new__(cls, val))
-
-
-class Stream(object):
-    """Represents a stream of markup events.
-    
-    This class is basically an iterator over the events.
-    
-    Stream events are tuples of the form::
-    
-      (kind, data, position)
-    
-    where ``kind`` is the event kind (such as `START`, `END`, `TEXT`, etc),
-    ``data`` depends on the kind of event, and ``position`` is a
-    ``(filename, line, offset)`` tuple that contains the location of the
-    original element or text in the input. If the original location is unknown,
-    ``position`` is ``(None, -1, -1)``.
-    
-    Also provided are ways to serialize the stream to text. The `serialize()`
-    method will return an iterator over generated strings, while `render()`
-    returns the complete generated text at once. Both accept various parameters
-    that impact the way the stream is serialized.
-    """
-    __slots__ = ['events']
-
-    START = StreamEventKind('START') #: a start tag
-    END = StreamEventKind('END') #: an end tag
-    TEXT = StreamEventKind('TEXT') #: literal text
-    DOCTYPE = StreamEventKind('DOCTYPE') #: doctype declaration
-    START_NS = StreamEventKind('START_NS') #: start namespace mapping
-    END_NS = StreamEventKind('END_NS') #: end namespace mapping
-    START_CDATA = StreamEventKind('START_CDATA') #: start CDATA section
-    END_CDATA = StreamEventKind('END_CDATA') #: end CDATA section
-    PI = StreamEventKind('PI') #: processing instruction
-    COMMENT = StreamEventKind('COMMENT') #: comment
-
-    def __init__(self, events):
-        """Initialize the stream with a sequence of markup events.
-        
-        :param events: a sequence or iterable providing the events
-        """
-        self.events = events
-
-    def __iter__(self):
-        return iter(self.events)
-
-    def __or__(self, function):
-        """Override the "bitwise or" operator to apply filters or serializers
-        to the stream, providing a syntax similar to pipes on Unix shells.
-        
-        Assume the following stream produced by the `HTML` function:
-        
-        >>> from genshi.input import HTML
-        >>> html = HTML('''<p onclick="alert('Whoa')">Hello, world!</p>''')
-        >>> print html
-        <p onclick="alert('Whoa')">Hello, world!</p>
-        
-        A filter such as the HTML sanitizer can be applied to that stream using
-        the pipe notation as follows:
-        
-        >>> from genshi.filters import HTMLSanitizer
-        >>> sanitizer = HTMLSanitizer()
-        >>> print html | sanitizer
-        <p>Hello, world!</p>
-        
-        Filters can be any function that accepts and produces a stream (where
-        a stream is anything that iterates over events):
-        
-        >>> def uppercase(stream):
-        ...     for kind, data, pos in stream:
-        ...         if kind is TEXT:
-        ...             data = data.upper()
-        ...         yield kind, data, pos
-        >>> print html | sanitizer | uppercase
-        <p>HELLO, WORLD!</p>
-        
-        Serializers can also be used with this notation:
-        
-        >>> from genshi.output import TextSerializer
-        >>> output = TextSerializer()
-        >>> print html | sanitizer | uppercase | output
-        HELLO, WORLD!
-        
-        Commonly, serializers should be used at the end of the "pipeline";
-        using them somewhere in the middle may produce unexpected results.
-        """
-        return Stream(_ensure(function(self)))
-
-    def filter(self, *filters):
-        """Apply filters to the stream.
-        
-        This method returns a new stream with the given filters applied. The
-        filters must be callables that accept the stream object as parameter,
-        and return the filtered stream.
-        
-        The call::
-        
-            stream.filter(filter1, filter2)
-        
-        is equivalent to::
-        
-            stream | filter1 | filter2
-        """
-        return reduce(operator.or_, (self,) + filters)
-
-    def render(self, method='xml', encoding='utf-8', **kwargs):
-        """Return a string representation of the stream.
-        
-        :param method: determines how the stream is serialized; can be either
-                       "xml", "xhtml", "html", "text", or a custom serializer
-                       class
-        :param encoding: how the output string should be encoded; if set to
-                         `None`, this method returns a `unicode` object
-
-        Any additional keyword arguments are passed to the serializer, and thus
-        depend on the `method` parameter value.
-        
-        :see: XMLSerializer.__init__, XHTMLSerializer.__init__,
-              HTMLSerializer.__init__, TextSerializer.__init__
-        """
-        generator = self.serialize(method=method, **kwargs)
-        output = u''.join(list(generator))
-        if encoding is not None:
-            errors = 'replace'
-            if method != 'text':
-                errors = 'xmlcharrefreplace'
-            return output.encode(encoding, errors)
-        return output
-
-    def select(self, path, namespaces=None, variables=None):
-        """Return a new stream that contains the events matching the given
-        XPath expression.
-        
-        :param path: a string containing the XPath expression
-        :param namespaces: mapping of namespace prefixes used in the path
-        :param variables: mapping of variable names to values
-        :return: the selected substream
-        :raises PathSyntaxError: if the given path expression is invalid or not
-                                 supported
-        """
-        from genshi.path import Path
-        return Path(path).select(self, namespaces, variables)
-
-    def serialize(self, method='xml', **kwargs):
-        """Generate strings corresponding to a specific serialization of the
-        stream.
-        
-        Unlike the `render()` method, this method is a generator that returns
-        the serialized output incrementally, as opposed to returning a single
-        string.
-        
-        :param method: determines how the stream is serialized; can be either
-                       "xml", "xhtml", "html", "text", or a custom serializer
-                       class
-        
-        Any additional keyword arguments are passed to the serializer, and thus
-        depend on the `method` parameter value.
-        
-        :see: XMLSerializer.__init__, XHTMLSerializer.__init__,
-              HTMLSerializer.__init__, TextSerializer.__init__
-        """
-        from genshi import output
-        cls = method
-        if isinstance(method, basestring):
-            cls = {'xml':   output.XMLSerializer,
-                   'xhtml': output.XHTMLSerializer,
-                   'html':  output.HTMLSerializer,
-                   'text':  output.TextSerializer}[method]
-        return cls(**kwargs)(_ensure(self))
-
-    def __str__(self):
-        return self.render()
-
-    def __unicode__(self):
-        return self.render(encoding=None)
-
-
-START = Stream.START
-END = Stream.END
-TEXT = Stream.TEXT
-DOCTYPE = Stream.DOCTYPE
-START_NS = Stream.START_NS
-END_NS = Stream.END_NS
-START_CDATA = Stream.START_CDATA
-END_CDATA = Stream.END_CDATA
-PI = Stream.PI
-COMMENT = Stream.COMMENT
-
-def _ensure(stream):
-    """Ensure that every item on the stream is actually a markup event."""
-    for event in stream:
-        if type(event) is not tuple:
-            if hasattr(event, 'totuple'):
-                event = event.totuple()
-            else:
-                event = TEXT, unicode(event), (None, -1, -1)
-        yield event
-
-
-class Attrs(tuple):
-    """Immutable sequence type that stores the attributes of an element.
-    
-    Ordering of the attributes is preserved, while access by name is also
-    supported.
-    
-    >>> attrs = Attrs([('href', '#'), ('title', 'Foo')])
-    >>> attrs
-    Attrs([('href', '#'), ('title', 'Foo')])
-    
-    >>> 'href' in attrs
-    True
-    >>> 'tabindex' in attrs
-    False
-    >>> attrs.get('title')
-    'Foo'
-    
-    Instances may not be manipulated directly. Instead, the operators ``|`` and
-    ``-`` can be used to produce new instances that have specific attributes
-    added, replaced or removed.
-    
-    To remove an attribute, use the ``-`` operator. The right hand side can be
-    either a string or a set/sequence of strings, identifying the name(s) of
-    the attribute(s) to remove:
-    
-    >>> attrs - 'title'
-    Attrs([('href', '#')])
-    >>> attrs - ('title', 'href')
-    Attrs()
-    
-    The original instance is not modified, but the operator can of course be
-    used with an assignment:
-
-    >>> attrs
-    Attrs([('href', '#'), ('title', 'Foo')])
-    >>> attrs -= 'title'
-    >>> attrs
-    Attrs([('href', '#')])
-    
-    To add a new attribute, use the ``|`` operator, where the right hand value
-    is a sequence of ``(name, value)`` tuples (which includes `Attrs`
-    instances):
-    
-    >>> attrs | [('title', 'Bar')]
-    Attrs([('href', '#'), ('title', 'Bar')])
-    
-    If the attributes already contain an attribute with a given name, the value
-    of that attribute is replaced:
-    
-    >>> attrs | [('href', 'http://example.org/')]
-    Attrs([('href', 'http://example.org/')])
-    """
-    __slots__ = []
-
-    def __contains__(self, name):
-        """Return whether the list includes an attribute with the specified
-        name.
-        """
-        for attr, _ in self:
-            if attr == name:
-                return True
-
-    def __getslice__(self, i, j):
-        return Attrs(tuple.__getslice__(self, i, j))
-
-    def __or__(self, attrs):
-        """Return a new instance that contains the attributes in `attrs` in
-        addition to any already existing attributes.
-        """
-        repl = dict([(an, av) for an, av in attrs if an in self])
-        return Attrs([(sn, repl.get(sn, sv)) for sn, sv in self] +
-                     [(an, av) for an, av in attrs if an not in self])
-
-    def __repr__(self):
-        if not self:
-            return 'Attrs()'
-        return 'Attrs([%s])' % ', '.join([repr(item) for item in self])
-
-    def __sub__(self, names):
-        """Return a new instance with all attributes with a name in `names` are
-        removed.
-        """
-        if isinstance(names, basestring):
-            names = (names,)
-        return Attrs([(name, val) for name, val in self if name not in names])
-
-    def get(self, name, default=None):
-        """Return the value of the attribute with the specified name, or the
-        value of the `default` parameter if no such attribute is found.
-        
-        :param name: the name of the attribute
-        :param default: the value to return when the attribute does not exist
-        :return: the attribute value, or the `default` value if that attribute
-                 does not exist
-        """
-        for attr, value in self:
-            if attr == name:
-                return value
-        return default
-
-    def totuple(self):
-        """Return the attributes as a markup event.
-        
-        The returned event is a `TEXT` event, the data is the value of all
-        attributes joined together.
-        
-        >>> Attrs([('href', '#'), ('title', 'Foo')]).totuple()
-        ('TEXT', u'#Foo', (None, -1, -1))
-        """
-        return TEXT, u''.join([x[1] for x in self]), (None, -1, -1)
-
-
-class Markup(unicode):
-    """Marks a string as being safe for inclusion in HTML/XML output without
-    needing to be escaped.
-    """
-    __slots__ = []
-
-    def __new__(cls, text='', *args):
-        if args:
-            text %= tuple(map(escape, args))
-        return unicode.__new__(cls, text)
-
-    def __add__(self, other):
-        return Markup(unicode(self) + unicode(escape(other)))
-
-    def __radd__(self, other):
-        return Markup(unicode(escape(other)) + unicode(self))
-
-    def __mod__(self, args):
-        if not isinstance(args, (list, tuple)):
-            args = [args]
-        return Markup(unicode.__mod__(self, tuple(map(escape, args))))
-
-    def __mul__(self, num):
-        return Markup(unicode(self) * num)
-
-    def __rmul__(self, num):
-        return Markup(num * unicode(self))
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, unicode(self))
-
-    def join(self, seq, escape_quotes=True):
-        """Return a `Markup` object which is the concatenation of the strings
-        in the given sequence, where this `Markup` object is the separator
-        between the joined elements.
-        
-        Any element in the sequence that is not a `Markup` instance is
-        automatically escaped.
-        
-        :param seq: the sequence of strings to join
-        :param escape_quotes: whether double quote characters in the elements
-                              should be escaped
-        :return: the joined `Markup` object
-        :see: `escape`
-        """
-        return Markup(unicode(self).join([escape(item, quotes=escape_quotes)
-                                          for item in seq]))
-
-    def escape(cls, text, quotes=True):
-        """Create a Markup instance from a string and escape special characters
-        it may contain (<, >, & and \").
-        
-        >>> escape('"1 < 2"')
-        <Markup u'&#34;1 &lt; 2&#34;'>
-        
-        If the `quotes` parameter is set to `False`, the \" character is left
-        as is. Escaping quotes is generally only required for strings that are
-        to be used in attribute values.
-        
-        >>> escape('"1 < 2"', quotes=False)
-        <Markup u'"1 &lt; 2"'>
-        
-        :param text: the text to escape
-        :param quotes: if ``True``, double quote characters are escaped in
-                       addition to the other special characters
-        :return: the escaped `Markup` string
-        :see: `genshi.core.escape`
-        """
-        if not text:
-            return cls()
-        if type(text) is cls:
-            return text
-        text = unicode(text).replace('&', '&amp;') \
-                            .replace('<', '&lt;') \
-                            .replace('>', '&gt;')
-        if quotes:
-            text = text.replace('"', '&#34;')
-        return cls(text)
-    escape = classmethod(escape)
-
-    def unescape(self):
-        """Reverse-escapes &, <, >, and \" and returns a `unicode` object.
-        
-        >>> Markup('1 &lt; 2').unescape()
-        u'1 < 2'
-        
-        :see: `genshi.core.unescape`
-        """
-        if not self:
-            return u''
-        return unicode(self).replace('&#34;', '"') \
-                            .replace('&gt;', '>') \
-                            .replace('&lt;', '<') \
-                            .replace('&amp;', '&')
-
-    def stripentities(self, keepxmlentities=False):
-        """Return a copy of the text with any character or numeric entities
-        replaced by the equivalent UTF-8 characters.
-        
-        If the `keepxmlentities` parameter is provided and evaluates to `True`,
-        the core XML entities (``&amp;``, ``&apos;``, ``&gt;``, ``&lt;`` and
-        ``&quot;``) are not stripped.
-        
-        :see: `genshi.util.stripentities`
-        """
-        return Markup(stripentities(self, keepxmlentities=keepxmlentities))
-
-    def striptags(self):
-        """Return a copy of the text with all XML/HTML tags removed.
-        
-        :see: `genshi.util.striptags`
-        """
-        return Markup(striptags(self))
-
-
-escape = Markup.escape
-
-def unescape(text):
-    """Reverse-escapes &, <, >, and \" and returns a `unicode` object.
-    
-    >>> unescape(Markup('1 &lt; 2'))
-    u'1 < 2'
-    
-    If the provided `text` object is not a `Markup` instance, the text is
-    returned as-is.
-    
-    >>> unescape('1 &lt; 2')
-    '1 &lt; 2'
-    
-    :param text: the text to unescape
-    """
-    if not isinstance(text, Markup):
-        return text
-    return text.unescape()
-
-
-class Namespace(object):
-    """Utility class creating and testing elements with a namespace.
-    
-    Internally, namespace URIs are encoded in the `QName` of any element or
-    attribute, the namespace URI being enclosed in curly braces. This class
-    helps create and test these strings.
-    
-    A `Namespace` object is instantiated with the namespace URI.
-    
-    >>> html = Namespace('http://www.w3.org/1999/xhtml')
-    >>> html
-    <Namespace "http://www.w3.org/1999/xhtml">
-    >>> html.uri
-    u'http://www.w3.org/1999/xhtml'
-    
-    The `Namespace` object can than be used to generate `QName` objects with
-    that namespace:
-    
-    >>> html.body
-    QName(u'http://www.w3.org/1999/xhtml}body')
-    >>> html.body.localname
-    u'body'
-    >>> html.body.namespace
-    u'http://www.w3.org/1999/xhtml'
-    
-    The same works using item access notation, which is useful for element or
-    attribute names that are not valid Python identifiers:
-    
-    >>> html['body']
-    QName(u'http://www.w3.org/1999/xhtml}body')
-    
-    A `Namespace` object can also be used to test whether a specific `QName`
-    belongs to that namespace using the ``in`` operator:
-    
-    >>> qname = html.body
-    >>> qname in html
-    True
-    >>> qname in Namespace('http://www.w3.org/2002/06/xhtml2')
-    False
-    """
-    def __new__(cls, uri):
-        if type(uri) is cls:
-            return uri
-        return object.__new__(cls, uri)
-
-    def __getnewargs__(self):
-        return (self.uri,)
-
-    def __getstate__(self):
-        return self.uri
-
-    def __setstate__(self, uri):
-        self.uri = uri
-
-    def __init__(self, uri):
-        self.uri = unicode(uri)
-
-    def __contains__(self, qname):
-        return qname.namespace == self.uri
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __eq__(self, other):
-        if isinstance(other, Namespace):
-            return self.uri == other.uri
-        return self.uri == other
-
-    def __getitem__(self, name):
-        return QName(self.uri + u'}' + name)
-    __getattr__ = __getitem__
-
-    def __repr__(self):
-        return '<Namespace "%s">' % self.uri
-
-    def __str__(self):
-        return self.uri.encode('utf-8')
-
-    def __unicode__(self):
-        return self.uri
-
-
-# The namespace used by attributes such as xml:lang and xml:space
-XML_NAMESPACE = Namespace('http://www.w3.org/XML/1998/namespace')
-
-
-class QName(unicode):
-    """A qualified element or attribute name.
-    
-    The unicode value of instances of this class contains the qualified name of
-    the element or attribute, in the form ``{namespace}localname``. The namespace
-    URI can be obtained through the additional `namespace` attribute, while the
-    local name can be accessed through the `localname` attribute.
-    
-    >>> qname = QName('foo')
-    >>> qname
-    QName(u'foo')
-    >>> qname.localname
-    u'foo'
-    >>> qname.namespace
-    
-    >>> qname = QName('http://www.w3.org/1999/xhtml}body')
-    >>> qname
-    QName(u'http://www.w3.org/1999/xhtml}body')
-    >>> qname.localname
-    u'body'
-    >>> qname.namespace
-    u'http://www.w3.org/1999/xhtml'
-    """
-    __slots__ = ['namespace', 'localname']
-
-    def __new__(cls, qname):
-        if type(qname) is cls:
-            return qname
-
-        parts = qname.split(u'}', 1)
-        if len(parts) > 1:
-            self = unicode.__new__(cls, u'{%s' % qname)
-            self.namespace, self.localname = map(unicode, parts)
-        else:
-            self = unicode.__new__(cls, qname)
-            self.namespace, self.localname = None, unicode(qname)
-        return self
-
-    def __getnewargs__(self):
-        return (self.lstrip('{'),)
-
-    def __repr__(self):
-        return 'QName(%s)' % unicode.__repr__(self.lstrip('{'))
diff --git a/generator/genshi/filters/__init__.py b/generator/genshi/filters/__init__.py
deleted file mode 100644
index 5d37b6a..0000000
--- a/generator/genshi/filters/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Implementation of a number of stream filters."""
-
-from genshi.filters.html import HTMLFormFiller, HTMLSanitizer
-from genshi.filters.i18n import Translator
-
-__docformat__ = 'restructuredtext en'
diff --git a/generator/genshi/filters/html.py b/generator/genshi/filters/html.py
deleted file mode 100644
index 28f8f3e..0000000
--- a/generator/genshi/filters/html.py
+++ /dev/null
@@ -1,323 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Implementation of a number of stream filters."""
-
-try:
-    frozenset
-except NameError:
-    from sets import ImmutableSet as frozenset
-import re
-
-from genshi.core import Attrs, QName, stripentities
-from genshi.core import END, START, TEXT
-
-__all__ = ['HTMLFormFiller', 'HTMLSanitizer']
-__docformat__ = 'restructuredtext en'
-
-
-class HTMLFormFiller(object):
-    """A stream filter that can populate HTML forms from a dictionary of values.
-    
-    >>> from genshi.input import HTML
-    >>> html = HTML('''<form>
-    ...   <p><input type="text" name="foo" /></p>
-    ... </form>''')
-    >>> filler = HTMLFormFiller(data={'foo': 'bar'})
-    >>> print html | filler
-    <form>
-      <p><input type="text" name="foo" value="bar"/></p>
-    </form>
-    """
-    # TODO: only select the first radio button, and the first select option
-    #       (if not in a multiple-select)
-    # TODO: only apply to elements in the XHTML namespace (or no namespace)?
-
-    def __init__(self, name=None, id=None, data=None):
-        """Create the filter.
-        
-        :param name: The name of the form that should be populated. If this
-                     parameter is given, only forms where the ``name`` attribute
-                     value matches the parameter are processed.
-        :param id: The ID of the form that should be populated. If this
-                   parameter is given, only forms where the ``id`` attribute
-                   value matches the parameter are processed.
-        :param data: The dictionary of form values, where the keys are the names
-                     of the form fields, and the values are the values to fill
-                     in.
-        """
-        self.name = name
-        self.id = id
-        if data is None:
-            data = {}
-        self.data = data
-
-    def __call__(self, stream):
-        """Apply the filter to the given stream.
-        
-        :param stream: the markup event stream to filter
-        """
-        in_form = in_select = in_option = in_textarea = False
-        select_value = option_value = textarea_value = None
-        option_start = option_text = None
-
-        for kind, data, pos in stream:
-
-            if kind is START:
-                tag, attrs = data
-                tagname = tag.localname
-
-                if tagname == 'form' and (
-                        self.name and attrs.get('name') == self.name or
-                        self.id and attrs.get('id') == self.id or
-                        not (self.id or self.name)):
-                    in_form = True
-
-                elif in_form:
-                    if tagname == 'input':
-                        type = attrs.get('type')
-                        if type in ('checkbox', 'radio'):
-                            name = attrs.get('name')
-                            if name:
-                                value = self.data.get(name)
-                                declval = attrs.get('value')
-                                checked = False
-                                if isinstance(value, (list, tuple)):
-                                    if declval:
-                                        checked = declval in [str(v) for v
-                                                              in value]
-                                    else:
-                                        checked = bool(filter(None, value))
-                                else:
-                                    if declval:
-                                        checked = declval == str(value)
-                                    elif type == 'checkbox':
-                                        checked = bool(value)
-                                if checked:
-                                    attrs |= [(QName('checked'), 'checked')]
-                                elif 'checked' in attrs:
-                                    attrs -= 'checked'
-                        elif type in (None, 'hidden', 'text'):
-                            name = attrs.get('name')
-                            if name:
-                                value = self.data.get(name)
-                                if isinstance(value, (list, tuple)):
-                                    value = value[0]
-                                if value is not None:
-                                    attrs |= [(QName('value'), unicode(value))]
-                    elif tagname == 'select':
-                        name = attrs.get('name')
-                        select_value = self.data.get(name)
-                        in_select = True
-                    elif tagname == 'textarea':
-                        name = attrs.get('name')
-                        textarea_value = self.data.get(name)
-                        if isinstance(textarea_value, (list, tuple)):
-                            textarea_value = textarea_value[0]
-                        in_textarea = True
-                    elif in_select and tagname == 'option':
-                        option_start = kind, data, pos
-                        option_value = attrs.get('value')
-                        in_option = True
-                        continue
-                yield kind, (tag, attrs), pos
-
-
-            elif in_form and kind is TEXT:
-                if in_select and in_option:
-                    if option_value is None:
-                        option_value = data
-                    option_text = kind, data, pos
-                    continue
-                elif in_textarea:
-                    continue
-                yield kind, data, pos
-
-            elif in_form and kind is END:
-                tagname = data.localname
-                if tagname == 'form':
-                    in_form = False
-                elif tagname == 'select':
-                    in_select = False
-                    select_value = None
-                elif in_select and tagname == 'option':
-                    if isinstance(select_value, (tuple, list)):
-                        selected = option_value in [str(v) for v
-                                                    in select_value]
-                    else:
-                        selected = option_value == str(select_value)
-                    okind, (tag, attrs), opos = option_start
-                    if selected:
-                        attrs |= [(QName('selected'), 'selected')]
-                    elif 'selected' in attrs:
-                        attrs -= 'selected'
-                    yield okind, (tag, attrs), opos
-                    if option_text:
-                        yield option_text
-                    in_option = False
-                    option_start = option_text = option_value = None
-                elif tagname == 'textarea':
-                    if textarea_value:
-                        yield TEXT, unicode(textarea_value), pos
-                    in_textarea = False
-                yield kind, data, pos
-
-            else:
-                yield kind, data, pos
-
-
-class HTMLSanitizer(object):
-    """A filter that removes potentially dangerous HTML tags and attributes
-    from the stream.
-    
-    >>> from genshi import HTML
-    >>> html = HTML('<div><script>alert(document.cookie)</script></div>')
-    >>> print html | HTMLSanitizer()
-    <div/>
-    
-    The default set of safe tags and attributes can be modified when the filter
-    is instantiated. For example, to allow inline ``style`` attributes, the
-    following instantation would work:
-    
-    >>> html = HTML('<div style="background: #000"></div>')
-    >>> sanitizer = HTMLSanitizer(safe_attrs=HTMLSanitizer.SAFE_ATTRS | set(['style']))
-    >>> print html | sanitizer
-    <div style="background: #000"/>
-    
-    Note that even in this case, the filter *does* attempt to remove dangerous
-    constructs from style attributes:
-
-    >>> html = HTML('<div style="background: url(javascript:void); color: #000"></div>')
-    >>> print html | sanitizer
-    <div style="color: #000"/>
-    
-    This handles HTML entities, unicode escapes in CSS and Javascript text, as
-    well as a lot of other things. However, the style tag is still excluded by
-    default because it is very hard for such sanitizing to be completely safe,
-    especially considering how much error recovery current web browsers perform.
-    """
-
-    SAFE_TAGS = frozenset(['a', 'abbr', 'acronym', 'address', 'area', 'b',
-        'big', 'blockquote', 'br', 'button', 'caption', 'center', 'cite',
-        'code', 'col', 'colgroup', 'dd', 'del', 'dfn', 'dir', 'div', 'dl', 'dt',
-        'em', 'fieldset', 'font', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
-        'hr', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'map',
-        'menu', 'ol', 'optgroup', 'option', 'p', 'pre', 'q', 's', 'samp',
-        'select', 'small', 'span', 'strike', 'strong', 'sub', 'sup', 'table',
-        'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'tr', 'tt', 'u',
-        'ul', 'var'])
-
-    SAFE_ATTRS = frozenset(['abbr', 'accept', 'accept-charset', 'accesskey',
-        'action', 'align', 'alt', 'axis', 'bgcolor', 'border', 'cellpadding',
-        'cellspacing', 'char', 'charoff', 'charset', 'checked', 'cite', 'class',
-        'clear', 'cols', 'colspan', 'color', 'compact', 'coords', 'datetime',
-        'dir', 'disabled', 'enctype', 'for', 'frame', 'headers', 'height',
-        'href', 'hreflang', 'hspace', 'id', 'ismap', 'label', 'lang',
-        'longdesc', 'maxlength', 'media', 'method', 'multiple', 'name',
-        'nohref', 'noshade', 'nowrap', 'prompt', 'readonly', 'rel', 'rev',
-        'rows', 'rowspan', 'rules', 'scope', 'selected', 'shape', 'size',
-        'span', 'src', 'start', 'summary', 'tabindex', 'target', 'title',
-        'type', 'usemap', 'valign', 'value', 'vspace', 'width'])
-
-    SAFE_SCHEMES = frozenset(['file', 'ftp', 'http', 'https', 'mailto', None])
-
-    URI_ATTRS = frozenset(['action', 'background', 'dynsrc', 'href', 'lowsrc',
-        'src'])
-
-    def __init__(self, safe_tags=SAFE_TAGS, safe_attrs=SAFE_ATTRS,
-                 safe_schemes=SAFE_SCHEMES, uri_attrs=URI_ATTRS):
-        """Create the sanitizer.
-        
-        The exact set of allowed elements and attributes can be configured.
-        
-        :param safe_tags: a set of tag names that are considered safe
-        :param safe_attrs: a set of attribute names that are considered safe
-        :param safe_schemes: a set of URI schemes that are considered safe
-        :param uri_attrs: a set of names of attributes that contain URIs
-        """
-        self.safe_tags = safe_tags
-        self.safe_attrs = safe_attrs
-        self.uri_attrs = uri_attrs
-        self.safe_schemes = safe_schemes
-
-    def __call__(self, stream):
-        """Apply the filter to the given stream.
-        
-        :param stream: the markup event stream to filter
-        """
-        waiting_for = None
-
-        def _get_scheme(href):
-            if ':' not in href:
-                return None
-            chars = [char for char in href.split(':', 1)[0] if char.isalnum()]
-            return ''.join(chars).lower()
-
-        for kind, data, pos in stream:
-            if kind is START:
-                if waiting_for:
-                    continue
-                tag, attrs = data
-                if tag not in self.safe_tags:
-                    waiting_for = tag
-                    continue
-
-                new_attrs = []
-                for attr, value in attrs:
-                    value = stripentities(value)
-                    if attr not in self.safe_attrs:
-                        continue
-                    elif attr in self.uri_attrs:
-                        # Don't allow URI schemes such as "javascript:"
-                        if _get_scheme(value) not in self.safe_schemes:
-                            continue
-                    elif attr == 'style':
-                        # Remove dangerous CSS declarations from inline styles
-                        decls = []
-                        value = self._replace_unicode_escapes(value)
-                        for decl in filter(None, value.split(';')):
-                            is_evil = False
-                            if 'expression' in decl:
-                                is_evil = True
-                            for m in re.finditer(r'url\s*\(([^)]+)', decl):
-                                if _get_scheme(m.group(1)) not in self.safe_schemes:
-                                    is_evil = True
-                                    break
-                            if not is_evil:
-                                decls.append(decl.strip())
-                        if not decls:
-                            continue
-                        value = '; '.join(decls)
-                    new_attrs.append((attr, value))
-
-                yield kind, (tag, Attrs(new_attrs)), pos
-
-            elif kind is END:
-                tag = data
-                if waiting_for:
-                    if waiting_for == tag:
-                        waiting_for = None
-                else:
-                    yield kind, data, pos
-
-            else:
-                if not waiting_for:
-                    yield kind, data, pos
-
-    _NORMALIZE_NEWLINES = re.compile(r'\r\n').sub
-    _UNICODE_ESCAPE = re.compile(r'\\([0-9a-fA-F]{1,6})\s?').sub
-
-    def _replace_unicode_escapes(self, text):
-        def _repl(match):
-            return unichr(int(match.group(1), 16))
-        return self._UNICODE_ESCAPE(_repl, self._NORMALIZE_NEWLINES('\n', text))
diff --git a/generator/genshi/filters/i18n.py b/generator/genshi/filters/i18n.py
deleted file mode 100644
index 83f3c8c..0000000
--- a/generator/genshi/filters/i18n.py
+++ /dev/null
@@ -1,266 +0,0 @@
-"""Utilities for internationalization and localization of templates."""
-
-try:
-    frozenset
-except NameError:
-    from sets import ImmutableSet as frozenset
-from gettext import gettext
-from opcode import opmap
-import re
-
-from genshi.core import Attrs, Namespace, QName, START, END, TEXT
-from genshi.template.base import Template, EXPR, SUB
-from genshi.template.markup import EXEC
-
-_LOAD_NAME = chr(opmap['LOAD_NAME'])
-_LOAD_CONST = chr(opmap['LOAD_CONST'])
-_CALL_FUNCTION = chr(opmap['CALL_FUNCTION'])
-_BINARY_ADD = chr(opmap['BINARY_ADD'])
-
-
-class Translator(object):
-    """Can extract and translate localizable strings from markup streams and
-    templates.
-    
-    For example, assume the followng template:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> 
-    >>> tmpl = MarkupTemplate('''<html xmlns:py="http://genshi.edgewall.org/">
-    ...   <head>
-    ...     <title>Example</title>
-    ...   </head>
-    ...   <body>
-    ...     <h1>Example</h1>
-    ...     <p>${_("Hello, %(name)s") % dict(name=username)}</p>
-    ...   </body>
-    ... </html>''', filename='example.html')
-    
-    For demonstration, we define a dummy ``gettext``-style function with a
-    hard-coded translation table, and pass that to the `Translator` initializer:
-    
-    >>> def pseudo_gettext(string):
-    ...     return {
-    ...         'Example': 'Beispiel',
-    ...         'Hello, %(name)s': 'Hallo, %(name)s'
-    ...     }[string]
-    >>> 
-    >>> translator = Translator(pseudo_gettext)
-    
-    Next, the translator needs to be prepended to any already defined filters
-    on the template:
-    
-    >>> tmpl.filters.insert(0, translator)
-    
-    When generating the template output, our hard-coded translations should be
-    applied as expected:
-    
-    >>> print tmpl.generate(username='Hans', _=pseudo_gettext)
-    <html>
-      <head>
-        <title>Beispiel</title>
-      </head>
-      <body>
-        <h1>Beispiel</h1>
-        <p>Hallo, Hans</p>
-      </body>
-    </html>
-    """
-
-    IGNORE_TAGS = frozenset([
-        QName('script'), QName('http://www.w3.org/1999/xhtml}script'),
-        QName('style'), QName('http://www.w3.org/1999/xhtml}style')
-    ])
-    INCLUDE_ATTRS = frozenset(['title', 'alt'])
-
-    def __init__(self, translate=gettext, ignore_tags=IGNORE_TAGS,
-                 include_attrs=INCLUDE_ATTRS):
-        """Initialize the translator.
-        
-        :param translate: the translation function, for example ``gettext`` or
-                          ``ugettext``.
-        :param ignore_tags: a set of tag names that should not be localized
-        :param include_attrs: a set of attribute names should be localized
-        """
-        self.translate = translate
-        self.ignore_tags = ignore_tags
-        self.include_attrs = include_attrs
-
-    def __call__(self, stream, ctxt=None, search_text=True):
-        """Translate any localizable strings in the given stream.
-        
-        This function shouldn't be called directly. Instead, an instance of
-        the `Translator` class should be registered as a filter with the
-        `Template` or the `TemplateLoader`, or applied as a regular stream
-        filter. If used as a template filter, it should be inserted in front of
-        all the default filters.
-        
-        :param stream: the markup event stream
-        :param ctxt: the template context (not used)
-        :param search_text: whether text nodes should be translated (used
-                            internally)
-        :return: the localized stream
-        """
-        ignore_tags = self.ignore_tags
-        include_attrs = self.include_attrs
-        translate = self.translate
-        skip = 0
-
-        for kind, data, pos in stream:
-
-            # skip chunks that should not be localized
-            if skip:
-                if kind is START:
-                    tag, attrs = data
-                    if tag in ignore_tags:
-                        skip += 1
-                elif kind is END:
-                    if tag in ignore_tags:
-                        skip -= 1
-                yield kind, data, pos
-                continue
-
-            # handle different events that can be localized
-            if kind is START:
-                tag, attrs = data
-                if tag in ignore_tags:
-                    skip += 1
-                    yield kind, data, pos
-                    continue
-
-                new_attrs = list(attrs)
-                changed = False
-                for name, value in attrs:
-                    if name in include_attrs:
-                        if isinstance(value, basestring):
-                            newval = ugettext(value)
-                        else:
-                            newval = list(self(value, ctxt, search_text=name in include_attrs))
-                        if newval != value:
-                            value = new_val
-                            changed = True
-                    new_attrs.append((name, value))
-                if changed:
-                    attrs = new_attrs
-
-                yield kind, (tag, attrs), pos
-
-            elif kind is TEXT:
-                text = data.strip()
-                if text:
-                    data = data.replace(text, translate(text))
-                yield kind, data, pos
-
-            elif kind is SUB:
-                subkind, substream = data
-                new_substream = list(self(substream, ctxt))
-                yield kind, (subkind, new_substream), pos
-
-            else:
-                yield kind, data, pos
-
-    GETTEXT_FUNCTIONS = ('_', 'gettext', 'ngettext', 'dgettext', 'dngettext',
-                         'ugettext', 'ungettext')
-
-    def extract(self, stream, gettext_functions=GETTEXT_FUNCTIONS):
-        """Extract localizable strings from the given template stream.
-        
-        For every string found, this function yields a ``(lineno, function,
-        message)`` tuple, where:
-        
-        * ``lineno`` is the number of the line on which the string was found,
-        * ``function`` is the name of the ``gettext`` function used (if the
-          string was extracted from embedded Python code), and
-        *  ``message`` is the string itself (a ``unicode`` object).
-        
-        >>> from genshi.template import MarkupTemplate
-        >>> 
-        >>> tmpl = MarkupTemplate('''<html xmlns:py="http://genshi.edgewall.org/">
-        ...   <head>
-        ...     <title>Example</title>
-        ...   </head>
-        ...   <body>
-        ...     <h1>Example</h1>
-        ...     <p>${_("Hello, %(name)s") % dict(name=username)}</p>
-        ...   </body>
-        ... </html>''', filename='example.html')
-        >>> 
-        >>> for lineno, funcname, message in Translator().extract(tmpl.stream):
-        ...    print "%d, %r, %r" % (lineno, funcname, message)
-        3, None, u'Example'
-        6, None, u'Example'
-        7, '_', u'Hello, %(name)s'
-
-        :param stream: the event stream to extract strings from; can be a
-                       regular stream or a template stream
-        :param gettext_functions: a sequence of function names that should be
-                                  treated as gettext-style localization
-                                  functions
-        """
-        tagname = None
-        skip = 0
-
-        for kind, data, pos in stream:
-            if skip:
-                if kind is START:
-                    tag, attrs = data
-                    if tag in self.ignore_tags:
-                        skip += 1
-                if kind is END:
-                    tag = data
-                    if tag in self.ignore_tags:
-                        skip -= 1
-                continue
-
-            if kind is START:
-                tag, attrs = data
-                if tag in self.ignore_tags:
-                    skip += 1
-                    continue
-
-                for name, value in attrs:
-                    if name in self.include_attrs:
-                        if isinstance(value, basestring):
-                            text = value.strip()
-                            if text:
-                                yield pos[1], None, text
-                        else:
-                            for lineno, funcname, text in harvest(value):
-                                yield lineno, funcname, text
-
-            elif kind is TEXT:
-                text = data.strip()
-                if text and filter(None, [ch.isalpha() for ch in text]):
-                    yield pos[1], None, text
-
-            elif kind is EXPR or kind is EXEC:
-                consts = dict([(n, chr(i) + '\x00') for i, n in
-                               enumerate(data.code.co_consts)])
-                gettext_locs = [consts[n] for n in gettext_functions
-                                if n in consts]
-                ops = [
-                    _LOAD_CONST, '(', '|'.join(gettext_locs), ')',
-                    _CALL_FUNCTION, '.\x00',
-                    '((?:', _BINARY_ADD, '|', _LOAD_CONST, '.\x00)+)'
-                ]
-                for loc, opcodes in re.findall(''.join(ops), data.code.co_code):
-                    funcname = data.code.co_consts[ord(loc[0])]
-                    strings = []
-                    opcodes = iter(opcodes)
-                    for opcode in opcodes:
-                        if opcode == _BINARY_ADD:
-                            arg = strings.pop()
-                            strings[-1] += arg
-                        else:
-                            arg = data.code.co_consts[ord(opcodes.next())]
-                            opcodes.next() # skip second byte
-                            if not isinstance(arg, basestring):
-                                break
-                            strings.append(unicode(arg))
-                    for string in strings:
-                        yield pos[1], funcname, string
-
-            elif kind is SUB:
-                subkind, substream = data
-                for lineno, funcname, text in self.harvest(substream):
-                    yield lineno, funcname, text
diff --git a/generator/genshi/input.py b/generator/genshi/input.py
deleted file mode 100644
index 50c88f2..0000000
--- a/generator/genshi/input.py
+++ /dev/null
@@ -1,444 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Support for constructing markup streams from files, strings, or other
-sources.
-"""
-
-from itertools import chain
-from xml.parsers import expat
-try:
-    frozenset
-except NameError:
-    from sets import ImmutableSet as frozenset
-import HTMLParser as html
-import htmlentitydefs
-from StringIO import StringIO
-
-from genshi.core import Attrs, QName, Stream, stripentities
-from genshi.core import DOCTYPE, START, END, START_NS, END_NS, TEXT, \
-                        START_CDATA, END_CDATA, PI, COMMENT
-
-__all__ = ['ET', 'ParseError', 'XMLParser', 'XML', 'HTMLParser', 'HTML']
-__docformat__ = 'restructuredtext en'
-
-def ET(element):
-    """Convert a given ElementTree element to a markup stream.
-    
-    :param element: an ElementTree element
-    :return: a markup stream
-    """
-    tag_name = QName(element.tag.lstrip('{'))
-    attrs = Attrs([(QName(attr), value) for attr, value in element.items()])
-
-    yield START, (tag_name, attrs), (None, -1, -1)
-    if element.text:
-        yield TEXT, element.text, (None, -1, -1)
-    for child in element.getchildren():
-        for item in ET(child):
-            yield item
-    yield END, tag_name, (None, -1, -1)
-    if element.tail:
-        yield TEXT, element.tail, (None, -1, -1)
-
-
-class ParseError(Exception):
-    """Exception raised when fatal syntax errors are found in the input being
-    parsed.
-    """
-
-    def __init__(self, message, filename=None, lineno=-1, offset=-1):
-        """Exception initializer.
-        
-        :param message: the error message from the parser
-        :param filename: the path to the file that was parsed
-        :param lineno: the number of the line on which the error was encountered
-        :param offset: the column number where the error was encountered
-        """
-        self.msg = message
-        if filename:
-            message += ', in ' + filename
-        Exception.__init__(self, message)
-        self.filename = filename or '<string>'
-        self.lineno = lineno
-        self.offset = offset
-
-
-class XMLParser(object):
-    """Generator-based XML parser based on roughly equivalent code in
-    Kid/ElementTree.
-    
-    The parsing is initiated by iterating over the parser object:
-    
-    >>> parser = XMLParser(StringIO('<root id="2"><child>Foo</child></root>'))
-    >>> for kind, data, pos in parser:
-    ...     print kind, data
-    START (QName(u'root'), Attrs([(QName(u'id'), u'2')]))
-    START (QName(u'child'), Attrs())
-    TEXT Foo
-    END child
-    END root
-    """
-
-    _entitydefs = ['<!ENTITY %s "&#%d;">' % (name, value) for name, value in
-                   htmlentitydefs.name2codepoint.items()]
-    _external_dtd = '\n'.join(_entitydefs)
-
-    def __init__(self, source, filename=None, encoding=None):
-        """Initialize the parser for the given XML input.
-        
-        :param source: the XML text as a file-like object
-        :param filename: the name of the file, if appropriate
-        :param encoding: the encoding of the file; if not specified, the
-                         encoding is assumed to be ASCII, UTF-8, or UTF-16, or
-                         whatever the encoding specified in the XML declaration
-                         (if any)
-        """
-        self.source = source
-        self.filename = filename
-
-        # Setup the Expat parser
-        parser = expat.ParserCreate(encoding, '}')
-        parser.buffer_text = True
-        parser.returns_unicode = True
-        parser.ordered_attributes = True
-
-        parser.StartElementHandler = self._handle_start
-        parser.EndElementHandler = self._handle_end
-        parser.CharacterDataHandler = self._handle_data
-        parser.StartDoctypeDeclHandler = self._handle_doctype
-        parser.StartNamespaceDeclHandler = self._handle_start_ns
-        parser.EndNamespaceDeclHandler = self._handle_end_ns
-        parser.StartCdataSectionHandler = self._handle_start_cdata
-        parser.EndCdataSectionHandler = self._handle_end_cdata
-        parser.ProcessingInstructionHandler = self._handle_pi
-        parser.CommentHandler = self._handle_comment
-
-        # Tell Expat that we'll handle non-XML entities ourselves
-        # (in _handle_other)
-        parser.DefaultHandler = self._handle_other
-        parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_ALWAYS)
-        parser.UseForeignDTD()
-        parser.ExternalEntityRefHandler = self._build_foreign
-
-        # Location reporting is only support in Python >= 2.4
-        if not hasattr(parser, 'CurrentLineNumber'):
-            self._getpos = self._getpos_unknown
-
-        self.expat = parser
-        self._queue = []
-
-    def parse(self):
-        """Generator that parses the XML source, yielding markup events.
-        
-        :return: a markup event stream
-        :raises ParseError: if the XML text is not well formed
-        """
-        def _generate():
-            try:
-                bufsize = 4 * 1024 # 4K
-                done = False
-                while 1:
-                    while not done and len(self._queue) == 0:
-                        data = self.source.read(bufsize)
-                        if data == '': # end of data
-                            if hasattr(self, 'expat'):
-                                self.expat.Parse('', True)
-                                del self.expat # get rid of circular references
-                            done = True
-                        else:
-                            if isinstance(data, unicode):
-                                data = data.encode('utf-8')
-                            self.expat.Parse(data, False)
-                    for event in self._queue:
-                        yield event
-                    self._queue = []
-                    if done:
-                        break
-            except expat.ExpatError, e:
-                msg = str(e)
-                raise ParseError(msg, self.filename, e.lineno, e.offset)
-        return Stream(_generate()).filter(_coalesce)
-
-    def __iter__(self):
-        return iter(self.parse())
-
-    def _build_foreign(self, context, base, sysid, pubid):
-        parser = self.expat.ExternalEntityParserCreate(context)
-        parser.ParseFile(StringIO(self._external_dtd))
-        return 1
-
-    def _enqueue(self, kind, data=None, pos=None):
-        if pos is None:
-            pos = self._getpos()
-        if kind is TEXT:
-            # Expat reports the *end* of the text event as current position. We
-            # try to fix that up here as much as possible. Unfortunately, the
-            # offset is only valid for single-line text. For multi-line text,
-            # it is apparently not possible to determine at what offset it
-            # started
-            if '\n' in data:
-                lines = data.splitlines()
-                lineno = pos[1] - len(lines) + 1
-                offset = -1
-            else:
-                lineno = pos[1]
-                offset = pos[2] - len(data)
-            pos = (pos[0], lineno, offset)
-        self._queue.append((kind, data, pos))
-
-    def _getpos_unknown(self):
-        return (self.filename, -1, -1)
-
-    def _getpos(self):
-        return (self.filename, self.expat.CurrentLineNumber,
-                self.expat.CurrentColumnNumber)
-
-    def _handle_start(self, tag, attrib):
-        attrs = Attrs([(QName(name), value) for name, value in
-                       zip(*[iter(attrib)] * 2)])
-        self._enqueue(START, (QName(tag), attrs))
-
-    def _handle_end(self, tag):
-        self._enqueue(END, QName(tag))
-
-    def _handle_data(self, text):
-        self._enqueue(TEXT, text)
-
-    def _handle_doctype(self, name, sysid, pubid, has_internal_subset):
-        self._enqueue(DOCTYPE, (name, pubid, sysid))
-
-    def _handle_start_ns(self, prefix, uri):
-        self._enqueue(START_NS, (prefix or '', uri))
-
-    def _handle_end_ns(self, prefix):
-        self._enqueue(END_NS, prefix or '')
-
-    def _handle_start_cdata(self):
-        self._enqueue(START_CDATA)
-
-    def _handle_end_cdata(self):
-        self._enqueue(END_CDATA)
-
-    def _handle_pi(self, target, data):
-        self._enqueue(PI, (target, data))
-
-    def _handle_comment(self, text):
-        self._enqueue(COMMENT, text)
-
-    def _handle_other(self, text):
-        if text.startswith('&'):
-            # deal with undefined entities
-            try:
-                text = unichr(htmlentitydefs.name2codepoint[text[1:-1]])
-                self._enqueue(TEXT, text)
-            except KeyError:
-                filename, lineno, offset = self._getpos()
-                error = expat.error('undefined entity "%s": line %d, column %d'
-                                    % (text, lineno, offset))
-                error.code = expat.errors.XML_ERROR_UNDEFINED_ENTITY
-                error.lineno = lineno
-                error.offset = offset
-                raise error
-
-
-def XML(text):
-    """Parse the given XML source and return a markup stream.
-    
-    Unlike with `XMLParser`, the returned stream is reusable, meaning it can be
-    iterated over multiple times:
-    
-    >>> xml = XML('<doc><elem>Foo</elem><elem>Bar</elem></doc>')
-    >>> print xml
-    <doc><elem>Foo</elem><elem>Bar</elem></doc>
-    >>> print xml.select('elem')
-    <elem>Foo</elem><elem>Bar</elem>
-    >>> print xml.select('elem/text()')
-    FooBar
-    
-    :param text: the XML source
-    :return: the parsed XML event stream
-    :raises ParseError: if the XML text is not well-formed
-    """
-    return Stream(list(XMLParser(StringIO(text))))
-
-
-class HTMLParser(html.HTMLParser, object):
-    """Parser for HTML input based on the Python `HTMLParser` module.
-    
-    This class provides the same interface for generating stream events as
-    `XMLParser`, and attempts to automatically balance tags.
-    
-    The parsing is initiated by iterating over the parser object:
-    
-    >>> parser = HTMLParser(StringIO('<UL compact><LI>Foo</UL>'))
-    >>> for kind, data, pos in parser:
-    ...     print kind, data
-    START (QName(u'ul'), Attrs([(QName(u'compact'), u'compact')]))
-    START (QName(u'li'), Attrs())
-    TEXT Foo
-    END li
-    END ul
-    """
-
-    _EMPTY_ELEMS = frozenset(['area', 'base', 'basefont', 'br', 'col', 'frame',
-                              'hr', 'img', 'input', 'isindex', 'link', 'meta',
-                              'param'])
-
-    def __init__(self, source, filename=None, encoding='utf-8'):
-        """Initialize the parser for the given HTML input.
-        
-        :param source: the HTML text as a file-like object
-        :param filename: the name of the file, if known
-        :param filename: encoding of the file; ignored if the input is unicode
-        """
-        html.HTMLParser.__init__(self)
-        self.source = source
-        self.filename = filename
-        self.encoding = encoding
-        self._queue = []
-        self._open_tags = []
-
-    def parse(self):
-        """Generator that parses the HTML source, yielding markup events.
-        
-        :return: a markup event stream
-        :raises ParseError: if the HTML text is not well formed
-        """
-        def _generate():
-            try:
-                bufsize = 4 * 1024 # 4K
-                done = False
-                while 1:
-                    while not done and len(self._queue) == 0:
-                        data = self.source.read(bufsize)
-                        if data == '': # end of data
-                            self.close()
-                            done = True
-                        else:
-                            self.feed(data)
-                    for kind, data, pos in self._queue:
-                        yield kind, data, pos
-                    self._queue = []
-                    if done:
-                        open_tags = self._open_tags
-                        open_tags.reverse()
-                        for tag in open_tags:
-                            yield END, QName(tag), pos
-                        break
-            except html.HTMLParseError, e:
-                msg = '%s: line %d, column %d' % (e.msg, e.lineno, e.offset)
-                raise ParseError(msg, self.filename, e.lineno, e.offset)
-        return Stream(_generate()).filter(_coalesce)
-
-    def __iter__(self):
-        return iter(self.parse())
-
-    def _enqueue(self, kind, data, pos=None):
-        if pos is None:
-            pos = self._getpos()
-        self._queue.append((kind, data, pos))
-
-    def _getpos(self):
-        lineno, column = self.getpos()
-        return (self.filename, lineno, column)
-
-    def handle_starttag(self, tag, attrib):
-        fixed_attrib = []
-        for name, value in attrib: # Fixup minimized attributes
-            if value is None:
-                value = unicode(name)
-            elif not isinstance(value, unicode):
-                value = value.decode(self.encoding, 'replace')
-            fixed_attrib.append((QName(name), stripentities(value)))
-
-        self._enqueue(START, (QName(tag), Attrs(fixed_attrib)))
-        if tag in self._EMPTY_ELEMS:
-            self._enqueue(END, QName(tag))
-        else:
-            self._open_tags.append(tag)
-
-    def handle_endtag(self, tag):
-        if tag not in self._EMPTY_ELEMS:
-            while self._open_tags:
-                open_tag = self._open_tags.pop()
-                self._enqueue(END, QName(open_tag))
-                if open_tag.lower() == tag.lower():
-                    break
-
-    def handle_data(self, text):
-        if not isinstance(text, unicode):
-            text = text.decode(self.encoding, 'replace')
-        self._enqueue(TEXT, text)
-
-    def handle_charref(self, name):
-        if name.lower().startswith('x'):
-            text = unichr(int(name[1:], 16))
-        else:
-            text = unichr(int(name))
-        self._enqueue(TEXT, text)
-
-    def handle_entityref(self, name):
-        try:
-            text = unichr(htmlentitydefs.name2codepoint[name])
-        except KeyError:
-            text = '&%s;' % name
-        self._enqueue(TEXT, text)
-
-    def handle_pi(self, data):
-        target, data = data.split(None, 1)
-        if data.endswith('?'):
-            data = data[:-1]
-        self._enqueue(PI, (target.strip(), data.strip()))
-
-    def handle_comment(self, text):
-        self._enqueue(COMMENT, text)
-
-
-def HTML(text, encoding='utf-8'):
-    """Parse the given HTML source and return a markup stream.
-    
-    Unlike with `HTMLParser`, the returned stream is reusable, meaning it can be
-    iterated over multiple times:
-    
-    >>> html = HTML('<body><h1>Foo</h1></body>')
-    >>> print html
-    <body><h1>Foo</h1></body>
-    >>> print html.select('h1')
-    <h1>Foo</h1>
-    >>> print html.select('h1/text()')
-    Foo
-    
-    :param text: the HTML source
-    :return: the parsed XML event stream
-    :raises ParseError: if the HTML text is not well-formed, and error recovery
-                        fails
-    """
-    return Stream(list(HTMLParser(StringIO(text), encoding=encoding)))
-
-def _coalesce(stream):
-    """Coalesces adjacent TEXT events into a single event."""
-    textbuf = []
-    textpos = None
-    for kind, data, pos in chain(stream, [(None, None, None)]):
-        if kind is TEXT:
-            textbuf.append(data)
-            if textpos is None:
-                textpos = pos
-        else:
-            if textbuf:
-                yield TEXT, u''.join(textbuf), textpos
-                del textbuf[:]
-                textpos = None
-            if kind:
-                yield kind, data, pos
diff --git a/generator/genshi/output.py b/generator/genshi/output.py
deleted file mode 100644
index 4efedf7..0000000
--- a/generator/genshi/output.py
+++ /dev/null
@@ -1,624 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""This module provides different kinds of serialization methods for XML event
-streams.
-"""
-
-from itertools import chain
-try:
-    frozenset
-except NameError:
-    from sets import ImmutableSet as frozenset
-import re
-
-from genshi.core import escape, Attrs, Markup, Namespace, QName, StreamEventKind
-from genshi.core import DOCTYPE, START, END, START_NS, END_NS, TEXT, \
-                        START_CDATA, END_CDATA, PI, COMMENT, XML_NAMESPACE
-
-__all__ = ['DocType', 'XMLSerializer', 'XHTMLSerializer', 'HTMLSerializer',
-           'TextSerializer']
-__docformat__ = 'restructuredtext en'
-
-
-class DocType(object):
-    """Defines a number of commonly used DOCTYPE declarations as constants."""
-
-    HTML_STRICT = (
-        'html', '-//W3C//DTD HTML 4.01//EN',
-        'http://www.w3.org/TR/html4/strict.dtd'
-    )
-    HTML_TRANSITIONAL = (
-        'html', '-//W3C//DTD HTML 4.01 Transitional//EN',
-        'http://www.w3.org/TR/html4/loose.dtd'
-    )
-    HTML = HTML_STRICT
-
-    XHTML_STRICT = (
-        'html', '-//W3C//DTD XHTML 1.0 Strict//EN',
-        'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
-    )
-    XHTML_TRANSITIONAL = (
-        'html', '-//W3C//DTD XHTML 1.0 Transitional//EN',
-        'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'
-    )
-    XHTML = XHTML_STRICT
-
-    HTML5 = ('html', None, None)
-
-
-class XMLSerializer(object):
-    """Produces XML text from an event stream.
-    
-    >>> from genshi.builder import tag
-    >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
-    >>> print ''.join(XMLSerializer()(elem.generate()))
-    <div><a href="foo"/><br/><hr noshade="True"/></div>
-    """
-
-    _PRESERVE_SPACE = frozenset()
-
-    def __init__(self, doctype=None, strip_whitespace=True,
-                 namespace_prefixes=None):
-        """Initialize the XML serializer.
-        
-        :param doctype: a ``(name, pubid, sysid)`` tuple that represents the
-                        DOCTYPE declaration that should be included at the top
-                        of the generated output
-        :param strip_whitespace: whether extraneous whitespace should be
-                                 stripped from the output
-        """
-        self.preamble = []
-        if doctype:
-            self.preamble.append((DOCTYPE, doctype, (None, -1, -1)))
-        self.filters = [EmptyTagFilter()]
-        if strip_whitespace:
-            self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE))
-        self.filters.append(NamespaceFlattener(prefixes=namespace_prefixes))
-
-    def __call__(self, stream):
-        have_doctype = False
-        in_cdata = False
-
-        stream = chain(self.preamble, stream)
-        for filter_ in self.filters:
-            stream = filter_(stream)
-        for kind, data, pos in stream:
-
-            if kind is START or kind is EMPTY:
-                tag, attrib = data
-                buf = ['<', tag]
-                for attr, value in attrib:
-                    buf += [' ', attr, '="', escape(value), '"']
-                buf.append(kind is EMPTY and '/>' or '>')
-                yield Markup(u''.join(buf))
-
-            elif kind is END:
-                yield Markup('</%s>' % data)
-
-            elif kind is TEXT:
-                if in_cdata:
-                    yield data
-                else:
-                    yield escape(data, quotes=False)
-
-            elif kind is COMMENT:
-                yield Markup('<!--%s-->' % data)
-
-            elif kind is DOCTYPE and not have_doctype:
-                name, pubid, sysid = data
-                buf = ['<!DOCTYPE %s']
-                if pubid:
-                    buf.append(' PUBLIC "%s"')
-                elif sysid:
-                    buf.append(' SYSTEM')
-                if sysid:
-                    buf.append(' "%s"')
-                buf.append('>\n')
-                yield Markup(u''.join(buf), *filter(None, data))
-                have_doctype = True
-
-            elif kind is START_CDATA:
-                yield Markup('<![CDATA[')
-                in_cdata = True
-
-            elif kind is END_CDATA:
-                yield Markup(']]>')
-                in_cdata = False
-
-            elif kind is PI:
-                yield Markup('<?%s %s?>' % data)
-
-
-class XHTMLSerializer(XMLSerializer):
-    """Produces XHTML text from an event stream.
-    
-    >>> from genshi.builder import tag
-    >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
-    >>> print ''.join(XHTMLSerializer()(elem.generate()))
-    <div><a href="foo"></a><br /><hr noshade="noshade" /></div>
-    """
-
-    _EMPTY_ELEMS = frozenset(['area', 'base', 'basefont', 'br', 'col', 'frame',
-                              'hr', 'img', 'input', 'isindex', 'link', 'meta',
-                              'param'])
-    _BOOLEAN_ATTRS = frozenset(['selected', 'checked', 'compact', 'declare',
-                                'defer', 'disabled', 'ismap', 'multiple',
-                                'nohref', 'noresize', 'noshade', 'nowrap'])
-    _PRESERVE_SPACE = frozenset([
-        QName('pre'), QName('http://www.w3.org/1999/xhtml}pre'),
-        QName('textarea'), QName('http://www.w3.org/1999/xhtml}textarea')
-    ])
-
-    def __init__(self, doctype=None, strip_whitespace=True,
-                 namespace_prefixes=None):
-        super(XHTMLSerializer, self).__init__(doctype, False)
-        self.filters = [EmptyTagFilter()]
-        if strip_whitespace:
-            self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE))
-        namespace_prefixes = namespace_prefixes or {}
-        namespace_prefixes['http://www.w3.org/1999/xhtml'] = ''
-        self.filters.append(NamespaceFlattener(prefixes=namespace_prefixes))
-
-    def __call__(self, stream):
-        boolean_attrs = self._BOOLEAN_ATTRS
-        empty_elems = self._EMPTY_ELEMS
-        have_doctype = False
-        in_cdata = False
-
-        stream = chain(self.preamble, stream)
-        for filter_ in self.filters:
-            stream = filter_(stream)
-        for kind, data, pos in stream:
-
-            if kind is START or kind is EMPTY:
-                tag, attrib = data
-                buf = ['<', tag]
-                for attr, value in attrib:
-                    if attr in boolean_attrs:
-                        value = attr
-                    buf += [' ', attr, '="', escape(value), '"']
-                if kind is EMPTY:
-                    if tag in empty_elems:
-                        buf.append(' />')
-                    else:
-                        buf.append('></%s>' % tag)
-                else:
-                    buf.append('>')
-                yield Markup(u''.join(buf))
-
-            elif kind is END:
-                yield Markup('</%s>' % data)
-
-            elif kind is TEXT:
-                if in_cdata:
-                    yield data
-                else:
-                    yield escape(data, quotes=False)
-
-            elif kind is COMMENT:
-                yield Markup('<!--%s-->' % data)
-
-            elif kind is DOCTYPE and not have_doctype:
-                name, pubid, sysid = data
-                buf = ['<!DOCTYPE %s']
-                if pubid:
-                    buf.append(' PUBLIC "%s"')
-                elif sysid:
-                    buf.append(' SYSTEM')
-                if sysid:
-                    buf.append(' "%s"')
-                buf.append('>\n')
-                yield Markup(u''.join(buf), *filter(None, data))
-                have_doctype = True
-
-            elif kind is START_CDATA:
-                yield Markup('<![CDATA[')
-                in_cdata = True
-
-            elif kind is END_CDATA:
-                yield Markup(']]>')
-                in_cdata = False
-
-            elif kind is PI:
-                yield Markup('<?%s %s?>' % data)
-
-
-class HTMLSerializer(XHTMLSerializer):
-    """Produces HTML text from an event stream.
-    
-    >>> from genshi.builder import tag
-    >>> elem = tag.div(tag.a(href='foo'), tag.br, tag.hr(noshade=True))
-    >>> print ''.join(HTMLSerializer()(elem.generate()))
-    <div><a href="foo"></a><br><hr noshade></div>
-    """
-
-    _NOESCAPE_ELEMS = frozenset([
-        QName('script'), QName('http://www.w3.org/1999/xhtml}script'),
-        QName('style'), QName('http://www.w3.org/1999/xhtml}style')
-    ])
-
-    def __init__(self, doctype=None, strip_whitespace=True):
-        """Initialize the HTML serializer.
-        
-        :param doctype: a ``(name, pubid, sysid)`` tuple that represents the
-                        DOCTYPE declaration that should be included at the top
-                        of the generated output
-        :param strip_whitespace: whether extraneous whitespace should be
-                                 stripped from the output
-        """
-        super(HTMLSerializer, self).__init__(doctype, False)
-        self.filters = [EmptyTagFilter()]
-        if strip_whitespace:
-            self.filters.append(WhitespaceFilter(self._PRESERVE_SPACE,
-                                                 self._NOESCAPE_ELEMS))
-        self.filters.append(NamespaceStripper('http://www.w3.org/1999/xhtml'))
-
-    def __call__(self, stream):
-        boolean_attrs = self._BOOLEAN_ATTRS
-        empty_elems = self._EMPTY_ELEMS
-        noescape_elems = self._NOESCAPE_ELEMS
-        have_doctype = False
-        noescape = False
-
-        stream = chain(self.preamble, stream)
-        for filter_ in self.filters:
-            stream = filter_(stream)
-        for kind, data, pos in stream:
-
-            if kind is START or kind is EMPTY:
-                tag, attrib = data
-                buf = ['<', tag]
-                for attr, value in attrib:
-                    if attr in boolean_attrs:
-                        if value:
-                            buf += [' ', attr]
-                    else:
-                        buf += [' ', attr, '="', escape(value), '"']
-                buf.append('>')
-                if kind is EMPTY:
-                    if tag not in empty_elems:
-                        buf.append('</%s>' % tag)
-                yield Markup(u''.join(buf))
-                if tag in noescape_elems:
-                    noescape = True
-
-            elif kind is END:
-                yield Markup('</%s>' % data)
-                noescape = False
-
-            elif kind is TEXT:
-                if noescape:
-                    yield data
-                else:
-                    yield escape(data, quotes=False)
-
-            elif kind is COMMENT:
-                yield Markup('<!--%s-->' % data)
-
-            elif kind is DOCTYPE and not have_doctype:
-                name, pubid, sysid = data
-                buf = ['<!DOCTYPE %s']
-                if pubid:
-                    buf.append(' PUBLIC "%s"')
-                elif sysid:
-                    buf.append(' SYSTEM')
-                if sysid:
-                    buf.append(' "%s"')
-                buf.append('>\n')
-                yield Markup(u''.join(buf), *filter(None, data))
-                have_doctype = True
-
-            elif kind is PI:
-                yield Markup('<?%s %s?>' % data)
-
-
-class TextSerializer(object):
-    """Produces plain text from an event stream.
-    
-    Only text events are included in the output. Unlike the other serializer,
-    special XML characters are not escaped:
-    
-    >>> from genshi.builder import tag
-    >>> elem = tag.div(tag.a('<Hello!>', href='foo'), tag.br)
-    >>> print elem
-    <div><a href="foo">&lt;Hello!&gt;</a><br/></div>
-    >>> print ''.join(TextSerializer()(elem.generate()))
-    <Hello!>
-
-    If text events contain literal markup (instances of the `Markup` class),
-    tags or entities are stripped from the output:
-    
-    >>> elem = tag.div(Markup('<a href="foo">Hello!</a><br/>'))
-    >>> print elem
-    <div><a href="foo">Hello!</a><br/></div>
-    >>> print ''.join(TextSerializer()(elem.generate()))
-    Hello!
-    """
-
-    def __call__(self, stream):
-        for event in stream:
-            if event[0] is TEXT:
-                data = event[1]
-                if type(data) is Markup:
-                    data = data.striptags().stripentities()
-                yield unicode(data)
-
-
-class EmptyTagFilter(object):
-    """Combines `START` and `STOP` events into `EMPTY` events for elements that
-    have no contents.
-    """
-
-    EMPTY = StreamEventKind('EMPTY')
-
-    def __call__(self, stream):
-        prev = (None, None, None)
-        for ev in stream:
-            if prev[0] is START:
-                if ev[0] is END:
-                    prev = EMPTY, prev[1], prev[2]
-                    yield prev
-                    continue
-                else:
-                    yield prev
-            if ev[0] is not START:
-                yield ev
-            prev = ev
-
-
-EMPTY = EmptyTagFilter.EMPTY
-
-
-class NamespaceFlattener(object):
-    r"""Output stream filter that removes namespace information from the stream,
-    instead adding namespace attributes and prefixes as needed.
-    
-    :param prefixes: optional mapping of namespace URIs to prefixes
-    
-    >>> from genshi.input import XML
-    >>> xml = XML('''<doc xmlns="NS1" xmlns:two="NS2">
-    ...   <two:item/>
-    ... </doc>''')
-    >>> for kind, data, pos in NamespaceFlattener()(xml):
-    ...     print kind, repr(data)
-    START (u'doc', Attrs([(u'xmlns', u'NS1'), (u'xmlns:two', u'NS2')]))
-    TEXT u'\n  '
-    START (u'two:item', Attrs())
-    END u'two:item'
-    TEXT u'\n'
-    END u'doc'
-    """
-
-    def __init__(self, prefixes=None):
-        self.prefixes = {XML_NAMESPACE.uri: 'xml'}
-        if prefixes is not None:
-            self.prefixes.update(prefixes)
-
-    def __call__(self, stream):
-        prefixes = dict([(v, [k]) for k, v in self.prefixes.items()])
-        namespaces = {XML_NAMESPACE.uri: ['xml']}
-        def _push_ns(prefix, uri):
-            namespaces.setdefault(uri, []).append(prefix)
-            prefixes.setdefault(prefix, []).append(uri)
-
-        ns_attrs = []
-        _push_ns_attr = ns_attrs.append
-        def _make_ns_attr(prefix, uri):
-            return u'xmlns%s' % (prefix and ':%s' % prefix or ''), uri
-
-        def _gen_prefix():
-            val = 0
-            while 1:
-                val += 1
-                yield 'ns%d' % val
-        _gen_prefix = _gen_prefix().next
-
-        for kind, data, pos in stream:
-
-            if kind is START or kind is EMPTY:
-                tag, attrs = data
-
-                tagname = tag.localname
-                tagns = tag.namespace
-                if tagns:
-                    if tagns in namespaces:
-                        prefix = namespaces[tagns][-1]
-                        if prefix:
-                            tagname = u'%s:%s' % (prefix, tagname)
-                    else:
-                        _push_ns_attr((u'xmlns', tagns))
-                        _push_ns('', tagns)
-
-                new_attrs = []
-                for attr, value in attrs:
-                    attrname = attr.localname
-                    attrns = attr.namespace
-                    if attrns:
-                        if attrns not in namespaces:
-                            prefix = _gen_prefix()
-                            _push_ns(prefix, attrns)
-                            _push_ns_attr(('xmlns:%s' % prefix, attrns))
-                        else:
-                            prefix = namespaces[attrns][-1]
-                        if prefix:
-                            attrname = u'%s:%s' % (prefix, attrname)
-                    new_attrs.append((attrname, value))
-
-                yield kind, (tagname, Attrs(ns_attrs + new_attrs)), pos
-                del ns_attrs[:]
-
-            elif kind is END:
-                tagname = data.localname
-                tagns = data.namespace
-                if tagns:
-                    prefix = namespaces[tagns][-1]
-                    if prefix:
-                        tagname = u'%s:%s' % (prefix, tagname)
-                yield kind, tagname, pos
-
-            elif kind is START_NS:
-                prefix, uri = data
-                if uri not in namespaces:
-                    prefix = prefixes.get(uri, [prefix])[-1]
-                    _push_ns_attr(_make_ns_attr(prefix, uri))
-                _push_ns(prefix, uri)
-
-            elif kind is END_NS:
-                if data in prefixes:
-                    uris = prefixes.get(data)
-                    uri = uris.pop()
-                    if not uris:
-                        del prefixes[data]
-                    if uri not in uris or uri != uris[-1]:
-                        uri_prefixes = namespaces[uri]
-                        uri_prefixes.pop()
-                        if not uri_prefixes:
-                            del namespaces[uri]
-                    if ns_attrs:
-                        attr = _make_ns_attr(data, uri)
-                        if attr in ns_attrs:
-                            ns_attrs.remove(attr)
-
-            else:
-                yield kind, data, pos
-
-
-class NamespaceStripper(object):
-    r"""Stream filter that removes all namespace information from a stream, and
-    optionally strips out all tags not in a given namespace.
-    
-    :param namespace: the URI of the namespace that should not be stripped. If
-                      not set, only elements with no namespace are included in
-                      the output.
-    
-    >>> from genshi.input import XML
-    >>> xml = XML('''<doc xmlns="NS1" xmlns:two="NS2">
-    ...   <two:item/>
-    ... </doc>''')
-    >>> for kind, data, pos in NamespaceStripper(Namespace('NS1'))(xml):
-    ...     print kind, repr(data)
-    START (u'doc', Attrs())
-    TEXT u'\n  '
-    TEXT u'\n'
-    END u'doc'
-    """
-
-    def __init__(self, namespace=None):
-        if namespace is not None:
-            self.namespace = Namespace(namespace)
-        else:
-            self.namespace = {}
-
-    def __call__(self, stream):
-        namespace = self.namespace
-
-        for kind, data, pos in stream:
-
-            if kind is START or kind is EMPTY:
-                tag, attrs = data
-                if tag.namespace and tag not in namespace:
-                    continue
-
-                new_attrs = []
-                for attr, value in attrs:
-                    if not attr.namespace or attr in namespace:
-                        new_attrs.append((attr, value))
-
-                data = tag.localname, Attrs(new_attrs)
-
-            elif kind is END:
-                if data.namespace and data not in namespace:
-                    continue
-                data = data.localname
-
-            elif kind is START_NS or kind is END_NS:
-                continue
-
-            yield kind, data, pos
-
-
-class WhitespaceFilter(object):
-    """A filter that removes extraneous ignorable white space from the
-    stream.
-    """
-
-    def __init__(self, preserve=None, noescape=None):
-        """Initialize the filter.
-        
-        :param preserve: a set or sequence of tag names for which white-space
-                         should be preserved
-        :param noescape: a set or sequence of tag names for which text content
-                         should not be escaped
-        
-        The `noescape` set is expected to refer to elements that cannot contain
-        further child elements (such as ``<style>`` or ``<script>`` in HTML
-        documents).
-        """
-        if preserve is None:
-            preserve = []
-        self.preserve = frozenset(preserve)
-        if noescape is None:
-            noescape = []
-        self.noescape = frozenset(noescape)
-
-    def __call__(self, stream, ctxt=None, space=XML_NAMESPACE['space'],
-                 trim_trailing_space=re.compile('[ \t]+(?=\n)').sub,
-                 collapse_lines=re.compile('\n{2,}').sub):
-        mjoin = Markup('').join
-        preserve_elems = self.preserve
-        preserve = 0
-        noescape_elems = self.noescape
-        noescape = False
-
-        textbuf = []
-        push_text = textbuf.append
-        pop_text = textbuf.pop
-        for kind, data, pos in chain(stream, [(None, None, None)]):
-
-            if kind is TEXT:
-                if noescape:
-                    data = Markup(data)
-                push_text(data)
-            else:
-                if textbuf:
-                    if len(textbuf) > 1:
-                        text = mjoin(textbuf, escape_quotes=False)
-                        del textbuf[:]
-                    else:
-                        text = escape(pop_text(), quotes=False)
-                    if not preserve:
-                        text = collapse_lines('\n', trim_trailing_space('', text))
-                    yield TEXT, Markup(text), pos
-
-                if kind is START:
-                    tag, attrs = data
-                    if preserve or (tag in preserve_elems or
-                                    attrs.get(space) == 'preserve'):
-                        preserve += 1
-                    if not noescape and tag in noescape_elems:
-                        noescape = True
-
-                elif kind is END:
-                    noescape = False
-                    if preserve:
-                        preserve -= 1
-
-                elif kind is START_CDATA:
-                    noescape = True
-
-                elif kind is END_CDATA:
-                    noescape = False
-
-                if kind:
-                    yield kind, data, pos
diff --git a/generator/genshi/path.py b/generator/genshi/path.py
deleted file mode 100644
index f08295a..0000000
--- a/generator/genshi/path.py
+++ /dev/null
@@ -1,1078 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Basic support for evaluating XPath expressions against streams.
-
->>> from genshi.input import XML
->>> doc = XML('''<doc>
-...  <items count="2">
-...       <item status="new">
-...         <summary>Foo</summary>
-...       </item>
-...       <item status="closed">
-...         <summary>Bar</summary>
-...       </item>
-...   </items>
-... </doc>''')
->>> print doc.select('items/item[@status="closed"]/summary/text()')
-Bar
-
-Because the XPath engine operates on markup streams (as opposed to tree
-structures), it only implements a subset of the full XPath 1.0 language.
-"""
-
-from math import ceil, floor
-import re
-
-from genshi.core import Stream, Attrs, Namespace, QName
-from genshi.core import START, END, TEXT, COMMENT, PI
-
-__all__ = ['Path', 'PathSyntaxError']
-__docformat__ = 'restructuredtext en'
-
-
-class Axis(object):
-    """Defines constants for the various supported XPath axes."""
-
-    ATTRIBUTE = 'attribute'
-    CHILD = 'child'
-    DESCENDANT = 'descendant'
-    DESCENDANT_OR_SELF = 'descendant-or-self'
-    SELF = 'self'
-
-    def forname(cls, name):
-        """Return the axis constant for the given name, or `None` if no such
-        axis was defined.
-        """
-        return getattr(cls, name.upper().replace('-', '_'), None)
-    forname = classmethod(forname)
-
-
-ATTRIBUTE = Axis.ATTRIBUTE
-CHILD = Axis.CHILD
-DESCENDANT = Axis.DESCENDANT
-DESCENDANT_OR_SELF = Axis.DESCENDANT_OR_SELF
-SELF = Axis.SELF
-
-
-class Path(object):
-    """Implements basic XPath support on streams.
-    
-    Instances of this class represent a "compiled" XPath expression, and provide
-    methods for testing the path against a stream, as well as extracting a
-    substream matching that path.
-    """
-
-    def __init__(self, text, filename=None, lineno=-1):
-        """Create the path object from a string.
-        
-        :param text: the path expression
-        """
-        self.source = text
-        self.paths = PathParser(text, filename, lineno).parse()
-
-    def __repr__(self):
-        paths = []
-        for path in self.paths:
-            steps = []
-            for axis, nodetest, predicates in path:
-                steps.append('%s::%s' % (axis, nodetest))
-                for predicate in predicates:
-                    steps[-1] += '[%s]' % predicate
-            paths.append('/'.join(steps))
-        return '<%s "%s">' % (self.__class__.__name__, '|'.join(paths))
-
-    def select(self, stream, namespaces=None, variables=None):
-        """Returns a substream of the given stream that matches the path.
-        
-        If there are no matches, this method returns an empty stream.
-        
-        >>> from genshi.input import XML
-        >>> xml = XML('<root><elem><child>Text</child></elem></root>')
-        
-        >>> print Path('.//child').select(xml)
-        <child>Text</child>
-        
-        >>> print Path('.//child/text()').select(xml)
-        Text
-        
-        :param stream: the stream to select from
-        :param namespaces: (optional) a mapping of namespace prefixes to URIs
-        :param variables: (optional) a mapping of variable names to values
-        :return: the substream matching the path, or an empty stream
-        """
-        if namespaces is None:
-            namespaces = {}
-        if variables is None:
-            variables = {}
-        stream = iter(stream)
-        def _generate():
-            test = self.test()
-            for event in stream:
-                result = test(event, namespaces, variables)
-                if result is True:
-                    yield event
-                    if event[0] is START:
-                        depth = 1
-                        while depth > 0:
-                            subevent = stream.next()
-                            if subevent[0] is START:
-                                depth += 1
-                            elif subevent[0] is END:
-                                depth -= 1
-                            yield subevent
-                            test(subevent, namespaces, variables,
-                                 updateonly=True)
-                elif result:
-                    yield result
-        return Stream(_generate())
-
-    def test(self, ignore_context=False):
-        """Returns a function that can be used to track whether the path matches
-        a specific stream event.
-        
-        The function returned expects the positional arguments ``event``,
-        ``namespaces`` and ``variables``. The first is a stream event, while the
-        latter two are a mapping of namespace prefixes to URIs, and a mapping
-        of variable names to values, respectively. In addition, the function
-        accepts an ``updateonly`` keyword argument that default to ``False``. If
-        it is set to ``True``, the function only updates its internal state,
-        but does not perform any tests or return a result.
-        
-        If the path matches the event, the function returns the match (for
-        example, a `START` or `TEXT` event.) Otherwise, it returns ``None``.
-        
-        >>> from genshi.input import XML
-        >>> xml = XML('<root><elem><child id="1"/></elem><child id="2"/></root>')
-        >>> test = Path('child').test()
-        >>> for event in xml:
-        ...     if test(event, {}, {}):
-        ...         print event[0], repr(event[1])
-        START (QName(u'child'), Attrs([(QName(u'id'), u'2')]))
-        """
-        paths = [(p, len(p), [0], [], [0] * len(p)) for p in [
-            (ignore_context and [_DOTSLASHSLASH] or []) + p for p in self.paths
-        ]]
-
-        def _test(event, namespaces, variables, updateonly=False):
-            kind, data, pos = event[:3]
-            retval = None
-            for steps, size, cursors, cutoff, counter in paths:
-                # Manage the stack that tells us "where we are" in the stream
-                if kind is END:
-                    if cursors:
-                        cursors.pop()
-                    continue
-                elif kind is START:
-                    cursors.append(cursors and cursors[-1] or 0)
-
-                if updateonly or retval or not cursors:
-                    continue
-                cursor = cursors[-1]
-                depth = len(cursors)
-
-                if cutoff and depth + int(kind is not START) > cutoff[0]:
-                    continue
-
-                ctxtnode = not ignore_context and kind is START \
-                                              and depth == 2
-                matched = None
-                while 1:
-                    # Fetch the next location step
-                    axis, nodetest, predicates = steps[cursor]
-
-                    # If this is the start event for the context node, and the
-                    # axis of the location step doesn't include the current
-                    # element, skip the test
-                    if ctxtnode and (axis is CHILD or axis is DESCENDANT):
-                        break
-
-                    # Is this the last step of the location path?
-                    last_step = cursor + 1 == size
-
-                    # Perform the actual node test
-                    matched = nodetest(kind, data, pos, namespaces, variables)
-
-                    # The node test matched
-                    if matched:
-
-                        # Check all the predicates for this step
-                        if predicates:
-                            for predicate in predicates:
-                                pretval = predicate(kind, data, pos, namespaces,
-                                                    variables)
-                                if type(pretval) is float:
-                                    counter[cursor] += 1
-                                    if counter[cursor] != int(pretval):
-                                        pretval = False
-                                if not pretval:
-                                    matched = None
-                                    break
-
-                        # Both the node test and the predicates matched
-                        if matched:
-                            if last_step:
-                                if not ctxtnode or kind is not START \
-                                        or axis is ATTRIBUTE or axis is SELF:
-                                    retval = matched
-                            elif not ctxtnode or axis is SELF \
-                                              or axis is DESCENDANT_OR_SELF:
-                                cursor += 1
-                                cursors[-1] = cursor
-                            cutoff[:] = []
-
-                    if kind is START:
-                        if last_step and not (axis is DESCENDANT or
-                                              axis is DESCENDANT_OR_SELF):
-                            cutoff[:] = [depth]
-
-                        elif steps[cursor][0] is ATTRIBUTE:
-                            # If the axis of the next location step is the
-                            # attribute axis, we need to move on to processing
-                            # that step without waiting for the next markup
-                            # event
-                            continue
-
-                    # We're done with this step if it's the last step or the
-                    # axis isn't "self"
-                    if not matched or last_step or not (
-                            axis is SELF or axis is DESCENDANT_OR_SELF):
-                        break
-
-                if (retval or not matched) and kind is START and \
-                        not (axis is DESCENDANT or axis is DESCENDANT_OR_SELF):
-                    # If this step is not a closure, it cannot be matched until
-                    # the current element is closed... so we need to move the
-                    # cursor back to the previous closure and retest that
-                    # against the current element
-                    backsteps = [(i, k, d, p) for i, (k, d, p)
-                                 in enumerate(steps[:cursor])
-                                 if k is DESCENDANT or k is DESCENDANT_OR_SELF]
-                    backsteps.reverse()
-                    for cursor, axis, nodetest, predicates in backsteps:
-                        if nodetest(kind, data, pos, namespaces, variables):
-                            cutoff[:] = []
-                            break
-                    cursors[-1] = cursor
-
-            return retval
-
-        return _test
-
-
-class PathSyntaxError(Exception):
-    """Exception raised when an XPath expression is syntactically incorrect."""
-
-    def __init__(self, message, filename=None, lineno=-1, offset=-1):
-        if filename:
-            message = '%s (%s, line %d)' % (message, filename, lineno)
-        Exception.__init__(self, message)
-        self.filename = filename
-        self.lineno = lineno
-        self.offset = offset
-
-
-class PathParser(object):
-    """Tokenizes and parses an XPath expression."""
-
-    _QUOTES = (("'", "'"), ('"', '"'))
-    _TOKENS = ('::', ':', '..', '.', '//', '/', '[', ']', '()', '(', ')', '@',
-               '=', '!=', '!', '|', ',', '>=', '>', '<=', '<', '$')
-    _tokenize = re.compile('("[^"]*")|(\'[^\']*\')|((?:\d+)?\.\d+)|(%s)|([^%s\s]+)|\s+' % (
-                           '|'.join([re.escape(t) for t in _TOKENS]),
-                           ''.join([re.escape(t[0]) for t in _TOKENS]))).findall
-
-    def __init__(self, text, filename=None, lineno=-1):
-        self.filename = filename
-        self.lineno = lineno
-        self.tokens = filter(None, [dqstr or sqstr or number or token or name
-                                    for dqstr, sqstr, number, token, name in
-                                    self._tokenize(text)])
-        self.pos = 0
-
-    # Tokenizer
-
-    at_end = property(lambda self: self.pos == len(self.tokens) - 1)
-    cur_token = property(lambda self: self.tokens[self.pos])
-
-    def next_token(self):
-        self.pos += 1
-        return self.tokens[self.pos]
-
-    def peek_token(self):
-        if not self.at_end:
-            return self.tokens[self.pos + 1]
-        return None
-
-    # Recursive descent parser
-
-    def parse(self):
-        """Parses the XPath expression and returns a list of location path
-        tests.
-        
-        For union expressions (such as `*|text()`), this function returns one
-        test for each operand in the union. For patch expressions that don't
-        use the union operator, the function always returns a list of size 1.
-        
-        Each path test in turn is a sequence of tests that correspond to the
-        location steps, each tuples of the form `(axis, testfunc, predicates)`
-        """
-        paths = [self._location_path()]
-        while self.cur_token == '|':
-            self.next_token()
-            paths.append(self._location_path())
-        if not self.at_end:
-            raise PathSyntaxError('Unexpected token %r after end of expression'
-                                  % self.cur_token, self.filename, self.lineno)
-        return paths
-
-    def _location_path(self):
-        steps = []
-        while True:
-            if self.cur_token.startswith('/'):
-                if self.cur_token == '//':
-                    steps.append((DESCENDANT_OR_SELF, NodeTest(), []))
-                elif not steps:
-                    raise PathSyntaxError('Absolute location paths not '
-                                          'supported', self.filename,
-                                          self.lineno)
-                self.next_token()
-
-            axis, nodetest, predicates = self._location_step()
-            if not axis:
-                axis = CHILD
-            steps.append((axis, nodetest, predicates))
-
-            if self.at_end or not self.cur_token.startswith('/'):
-                break
-
-        return steps
-
-    def _location_step(self):
-        if self.cur_token == '@':
-            axis = ATTRIBUTE
-            self.next_token()
-        elif self.cur_token == '.':
-            axis = SELF
-        elif self.cur_token == '..':
-            raise PathSyntaxError('Unsupported axis "parent"', self.filename,
-                                  self.lineno)
-        elif self.peek_token() == '::':
-            axis = Axis.forname(self.cur_token)
-            if axis is None:
-                raise PathSyntaxError('Unsupport axis "%s"' % axis,
-                                      self.filename, self.lineno)
-            self.next_token()
-            self.next_token()
-        else:
-            axis = None
-        nodetest = self._node_test(axis or CHILD)
-        predicates = []
-        while self.cur_token == '[':
-            predicates.append(self._predicate())
-        return axis, nodetest, predicates
-
-    def _node_test(self, axis=None):
-        test = prefix = None
-        next_token = self.peek_token()
-        if next_token in ('(', '()'): # Node type test
-            test = self._node_type()
-
-        elif next_token == ':': # Namespace prefix
-            prefix = self.cur_token
-            self.next_token()
-            localname = self.next_token()
-            if localname == '*':
-                test = QualifiedPrincipalTypeTest(axis, prefix)
-            else:
-                test = QualifiedNameTest(axis, prefix, localname)
-
-        else: # Name test
-            if self.cur_token == '*':
-                test = PrincipalTypeTest(axis)
-            elif self.cur_token == '.':
-                test = NodeTest()
-            else:
-                test = LocalNameTest(axis, self.cur_token)
-
-        if not self.at_end:
-            self.next_token()
-        return test
-
-    def _node_type(self):
-        name = self.cur_token
-        self.next_token()
-
-        args = []
-        if self.cur_token != '()':
-            # The processing-instruction() function optionally accepts the
-            # name of the PI as argument, which must be a literal string
-            self.next_token() # (
-            if self.cur_token != ')':
-                string = self.cur_token
-                if (string[0], string[-1]) in self._QUOTES:
-                    string = string[1:-1]
-                args.append(string)
-
-        cls = _nodetest_map.get(name)
-        if not cls:
-            raise PathSyntaxError('%s() not allowed here' % name, self.filename,
-                                  self.lineno)
-        return cls(*args)
-
-    def _predicate(self):
-        assert self.cur_token == '['
-        self.next_token()
-        expr = self._or_expr()
-        if self.cur_token != ']':
-            raise PathSyntaxError('Expected "]" to close predicate, '
-                                  'but found "%s"' % self.cur_token,
-                                  self.filename, self.lineno)
-        if not self.at_end:
-            self.next_token()
-        return expr
-
-    def _or_expr(self):
-        expr = self._and_expr()
-        while self.cur_token == 'or':
-            self.next_token()
-            expr = OrOperator(expr, self._and_expr())
-        return expr
-
-    def _and_expr(self):
-        expr = self._equality_expr()
-        while self.cur_token == 'and':
-            self.next_token()
-            expr = AndOperator(expr, self._equality_expr())
-        return expr
-
-    def _equality_expr(self):
-        expr = self._relational_expr()
-        while self.cur_token in ('=', '!='):
-            op = _operator_map[self.cur_token]
-            self.next_token()
-            expr = op(expr, self._relational_expr())
-        return expr
-
-    def _relational_expr(self):
-        expr = self._primary_expr()
-        while self.cur_token in ('>', '>=', '<', '>='):
-            op = _operator_map[self.cur_token]
-            self.next_token()
-            expr = op(expr, self._primary_expr())
-        return expr
-
-    def _primary_expr(self):
-        token = self.cur_token
-        if len(token) > 1 and (token[0], token[-1]) in self._QUOTES:
-            self.next_token()
-            return StringLiteral(token[1:-1])
-        elif token[0].isdigit() or token[0] == '.':
-            self.next_token()
-            return NumberLiteral(float(token))
-        elif token == '$':
-            token = self.next_token()
-            self.next_token()
-            return VariableReference(token)
-        elif not self.at_end and self.peek_token().startswith('('):
-            return self._function_call()
-        else:
-            axis = None
-            if token == '@':
-                axis = ATTRIBUTE
-                self.next_token()
-            return self._node_test(axis)
-
-    def _function_call(self):
-        name = self.cur_token
-        if self.next_token() == '()':
-            args = []
-        else:
-            assert self.cur_token == '('
-            self.next_token()
-            args = [self._or_expr()]
-            while self.cur_token == ',':
-                self.next_token()
-                args.append(self._or_expr())
-            if not self.cur_token == ')':
-                raise PathSyntaxError('Expected ")" to close function argument '
-                                      'list, but found "%s"' % self.cur_token,
-                                      self.filename, self.lineno)
-        self.next_token()
-        cls = _function_map.get(name)
-        if not cls:
-            raise PathSyntaxError('Unsupported function "%s"' % name,
-                                  self.filename, self.lineno)
-        return cls(*args)
-
-
-# Node tests
-
-class PrincipalTypeTest(object):
-    """Node test that matches any event with the given principal type."""
-    __slots__ = ['principal_type']
-    def __init__(self, principal_type):
-        self.principal_type = principal_type
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            if self.principal_type is ATTRIBUTE:
-                return data[1] or None
-            else:
-                return True
-    def __repr__(self):
-        return '*'
-
-class QualifiedPrincipalTypeTest(object):
-    """Node test that matches any event with the given principal type in a
-    specific namespace."""
-    __slots__ = ['principal_type', 'prefix']
-    def __init__(self, principal_type, prefix):
-        self.principal_type = principal_type
-        self.prefix = prefix
-    def __call__(self, kind, data, pos, namespaces, variables):
-        namespace = Namespace(namespaces.get(self.prefix))
-        if kind is START:
-            if self.principal_type is ATTRIBUTE and data[1]:
-                return Attrs([(name, value) for name, value in data[1]
-                              if name in namespace]) or None
-            else:
-                return data[0] in namespace
-    def __repr__(self):
-        return '%s:*' % self.prefix
-
-class LocalNameTest(object):
-    """Node test that matches any event with the given principal type and
-    local name.
-    """
-    __slots__ = ['principal_type', 'name']
-    def __init__(self, principal_type, name):
-        self.principal_type = principal_type
-        self.name = name
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            if self.principal_type is ATTRIBUTE and self.name in data[1]:
-                return data[1].get(self.name)
-            else:
-                return data[0].localname == self.name
-    def __repr__(self):
-        return self.name
-
-class QualifiedNameTest(object):
-    """Node test that matches any event with the given principal type and
-    qualified name.
-    """
-    __slots__ = ['principal_type', 'prefix', 'name']
-    def __init__(self, principal_type, prefix, name):
-        self.principal_type = principal_type
-        self.prefix = prefix
-        self.name = name
-    def __call__(self, kind, data, pos, namespaces, variables):
-        qname = QName('%s}%s' % (namespaces.get(self.prefix), self.name))
-        if kind is START:
-            if self.principal_type is ATTRIBUTE and qname in data[1]:
-                return data[1].get(qname)
-            else:
-                return data[0] == qname
-    def __repr__(self):
-        return '%s:%s' % (self.prefix, self.name)
-
-class CommentNodeTest(object):
-    """Node test that matches any comment events."""
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return kind is COMMENT
-    def __repr__(self):
-        return 'comment()'
-
-class NodeTest(object):
-    """Node test that matches any node."""
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            return True
-        return kind, data, pos
-    def __repr__(self):
-        return 'node()'
-
-class ProcessingInstructionNodeTest(object):
-    """Node test that matches any processing instruction event."""
-    __slots__ = ['target']
-    def __init__(self, target=None):
-        self.target = target
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return kind is PI and (not self.target or data[0] == self.target)
-    def __repr__(self):
-        arg = ''
-        if self.target:
-            arg = '"' + self.target + '"'
-        return 'processing-instruction(%s)' % arg
-
-class TextNodeTest(object):
-    """Node test that matches any text event."""
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return kind is TEXT
-    def __repr__(self):
-        return 'text()'
-
-_nodetest_map = {'comment': CommentNodeTest, 'node': NodeTest,
-                 'processing-instruction': ProcessingInstructionNodeTest,
-                 'text': TextNodeTest}
-
-# Functions
-
-class Function(object):
-    """Base class for function nodes in XPath expressions."""
-
-class BooleanFunction(Function):
-    """The `boolean` function, which converts its argument to a boolean
-    value.
-    """
-    __slots__ = ['expr']
-    def __init__(self, expr):
-        self.expr = expr
-    def __call__(self, kind, data, pos, namespaces, variables):
-        val = self.expr(kind, data, pos, namespaces, variables)
-        return bool(val)
-    def __repr__(self):
-        return 'boolean(%r)' % self.expr
-
-class CeilingFunction(Function):
-    """The `ceiling` function, which returns the nearest lower integer number
-    for the given number.
-    """
-    __slots__ = ['number']
-    def __init__(self, number):
-        self.number = number
-    def __call__(self, kind, data, pos, namespaces, variables):
-        number = self.number(kind, data, pos, namespaces, variables)
-        return ceil(float(number))
-    def __repr__(self):
-        return 'ceiling(%r)' % self.number
-
-class ConcatFunction(Function):
-    """The `concat` function, which concatenates (joins) the variable number of
-    strings it gets as arguments.
-    """
-    __slots__ = ['exprs']
-    def __init__(self, *exprs):
-        self.exprs = exprs
-    def __call__(self, kind, data, pos, namespaces, variables):
-        strings = []
-        for item in [expr(kind, data, pos, namespaces, variables)
-                     for expr in self.exprs]:
-            strings.append(item)
-        return u''.join(strings)
-    def __repr__(self):
-        return 'concat(%s)' % ', '.join([repr(expr) for expr in self.exprs])
-
-class ContainsFunction(Function):
-    """The `contains` function, which returns whether a string contains a given
-    substring.
-    """
-    __slots__ = ['string1', 'string2']
-    def __init__(self, string1, string2):
-        self.string1 = string1
-        self.string2 = string2
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string1 = self.string1(kind, data, pos, namespaces, variables)
-        string2 = self.string2(kind, data, pos, namespaces, variables)
-        return string2 in string1
-    def __repr__(self):
-        return 'contains(%r, %r)' % (self.string1, self.string2)
-
-class FalseFunction(Function):
-    """The `false` function, which always returns the boolean `false` value."""
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return False
-    def __repr__(self):
-        return 'false()'
-
-class FloorFunction(Function):
-    """The `ceiling` function, which returns the nearest higher integer number
-    for the given number.
-    """
-    __slots__ = ['number']
-    def __init__(self, number):
-        self.number = number
-    def __call__(self, kind, data, pos, namespaces, variables):
-        number = self.number(kind, data, pos, namespaces, variables)
-        return floor(float(number))
-    def __repr__(self):
-        return 'floor(%r)' % self.number
-
-class LocalNameFunction(Function):
-    """The `local-name` function, which returns the local name of the current
-    element.
-    """
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            return data[0].localname
-    def __repr__(self):
-        return 'local-name()'
-
-class NameFunction(Function):
-    """The `name` function, which returns the qualified name of the current
-    element.
-    """
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            return data[0]
-    def __repr__(self):
-        return 'name()'
-
-class NamespaceUriFunction(Function):
-    """The `namespace-uri` function, which returns the namespace URI of the
-    current element.
-    """
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        if kind is START:
-            return data[0].namespace
-    def __repr__(self):
-        return 'namespace-uri()'
-
-class NotFunction(Function):
-    """The `not` function, which returns the negated boolean value of its
-    argument.
-    """
-    __slots__ = ['expr']
-    def __init__(self, expr):
-        self.expr = expr
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return not self.expr(kind, data, pos, namespaces, variables)
-    def __repr__(self):
-        return 'not(%s)' % self.expr
-
-class NormalizeSpaceFunction(Function):
-    """The `normalize-space` function, which removes leading and trailing
-    whitespace in the given string, and replaces multiple adjacent whitespace
-    characters inside the string with a single space.
-    """
-    __slots__ = ['expr']
-    _normalize = re.compile(r'\s{2,}').sub
-    def __init__(self, expr):
-        self.expr = expr
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string = self.expr(kind, data, pos, namespaces, variables)
-        return self._normalize(' ', string.strip())
-    def __repr__(self):
-        return 'normalize-space(%s)' % repr(self.expr)
-
-class NumberFunction(Function):
-    """The `number` function that converts its argument to a number."""
-    __slots__ = ['expr']
-    def __init__(self, expr):
-        self.expr = expr
-    def __call__(self, kind, data, pos, namespaces, variables):
-        val = self.expr(kind, data, pos, namespaces, variables)
-        return float(val)
-    def __repr__(self):
-        return 'number(%r)' % self.expr
-
-class RoundFunction(Function):
-    """The `round` function, which returns the nearest integer number for the
-    given number.
-    """
-    __slots__ = ['number']
-    def __init__(self, number):
-        self.number = number
-    def __call__(self, kind, data, pos, namespaces, variables):
-        number = self.number(kind, data, pos, namespaces, variables)
-        return round(float(number))
-    def __repr__(self):
-        return 'round(%r)' % self.number
-
-class StartsWithFunction(Function):
-    """The `starts-with` function that returns whether one string starts with
-    a given substring.
-    """
-    __slots__ = ['string1', 'string2']
-    def __init__(self, string1, string2):
-        self.string1 = string1
-        self.string2 = string2
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string1 = self.string1(kind, data, pos, namespaces, variables)
-        string2 = self.string2(kind, data, pos, namespaces, variables)
-        return string1.startswith(string2)
-    def __repr__(self):
-        return 'starts-with(%r, %r)' % (self.string1, self.string2)
-
-class StringLengthFunction(Function):
-    """The `string-length` function that returns the length of the given
-    string.
-    """
-    __slots__ = ['expr']
-    def __init__(self, expr):
-        self.expr = expr
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string = self.expr(kind, data, pos, namespaces, variables)
-        return len(string)
-    def __repr__(self):
-        return 'string-length(%r)' % self.expr
-
-class SubstringFunction(Function):
-    """The `substring` function that returns the part of a string that starts
-    at the given offset, and optionally limited to the given length.
-    """
-    __slots__ = ['string', 'start', 'length']
-    def __init__(self, string, start, length=None):
-        self.string = string
-        self.start = start
-        self.length = length
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string = self.string(kind, data, pos, namespaces, variables)
-        start = self.start(kind, data, pos, namespaces, variables)
-        length = 0
-        if self.length is not None:
-            length = self.length(kind, data, pos, namespaces, variables)
-        return string[int(start):len(string) - int(length)]
-    def __repr__(self):
-        if self.length is not None:
-            return 'substring(%r, %r, %r)' % (self.string, self.start,
-                                              self.length)
-        else:
-            return 'substring(%r, %r)' % (self.string, self.start)
-
-class SubstringAfterFunction(Function):
-    """The `substring-after` function that returns the part of a string that
-    is found after the given substring.
-    """
-    __slots__ = ['string1', 'string2']
-    def __init__(self, string1, string2):
-        self.string1 = string1
-        self.string2 = string2
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string1 = self.string1(kind, data, pos, namespaces, variables)
-        string2 = self.string2(kind, data, pos, namespaces, variables)
-        index = string1.find(string2)
-        if index >= 0:
-            return string1[index + len(string2):]
-        return u''
-    def __repr__(self):
-        return 'substring-after(%r, %r)' % (self.string1, self.string2)
-
-class SubstringBeforeFunction(Function):
-    """The `substring-before` function that returns the part of a string that
-    is found before the given substring.
-    """
-    __slots__ = ['string1', 'string2']
-    def __init__(self, string1, string2):
-        self.string1 = string1
-        self.string2 = string2
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string1 = self.string1(kind, data, pos, namespaces, variables)
-        string2 = self.string2(kind, data, pos, namespaces, variables)
-        index = string1.find(string2)
-        if index >= 0:
-            return string1[:index]
-        return u''
-    def __repr__(self):
-        return 'substring-after(%r, %r)' % (self.string1, self.string2)
-
-class TranslateFunction(Function):
-    """The `translate` function that translates a set of characters in a
-    string to target set of characters.
-    """
-    __slots__ = ['string', 'fromchars', 'tochars']
-    def __init__(self, string, fromchars, tochars):
-        self.string = string
-        self.fromchars = fromchars
-        self.tochars = tochars
-    def __call__(self, kind, data, pos, namespaces, variables):
-        string = self.string(kind, data, pos, namespaces, variables)
-        fromchars = self.fromchars(kind, data, pos, namespaces, variables)
-        tochars = self.tochars(kind, data, pos, namespaces, variables)
-        table = dict(zip([ord(c) for c in fromchars],
-                         [ord(c) for c in tochars]))
-        return string.translate(table)
-    def __repr__(self):
-        return 'translate(%r, %r, %r)' % (self.string, self.fromchars,
-                                          self.tochars)
-
-class TrueFunction(Function):
-    """The `true` function, which always returns the boolean `true` value."""
-    __slots__ = []
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return True
-    def __repr__(self):
-        return 'true()'
-
-_function_map = {'boolean': BooleanFunction, 'ceiling': CeilingFunction,
-                 'concat': ConcatFunction, 'contains': ContainsFunction,
-                 'false': FalseFunction, 'floor': FloorFunction,
-                 'local-name': LocalNameFunction, 'name': NameFunction,
-                 'namespace-uri': NamespaceUriFunction,
-                 'normalize-space': NormalizeSpaceFunction, 'not': NotFunction,
-                 'number': NumberFunction, 'round': RoundFunction,
-                 'starts-with': StartsWithFunction,
-                 'string-length': StringLengthFunction,
-                 'substring': SubstringFunction,
-                 'substring-after': SubstringAfterFunction,
-                 'substring-before': SubstringBeforeFunction,
-                 'translate': TranslateFunction, 'true': TrueFunction}
-
-# Literals & Variables
-
-class Literal(object):
-    """Abstract base class for literal nodes."""
-
-class StringLiteral(Literal):
-    """A string literal node."""
-    __slots__ = ['text']
-    def __init__(self, text):
-        self.text = text
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return self.text
-    def __repr__(self):
-        return '"%s"' % self.text
-
-class NumberLiteral(Literal):
-    """A number literal node."""
-    __slots__ = ['number']
-    def __init__(self, number):
-        self.number = number
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return self.number
-    def __repr__(self):
-        return str(self.number)
-
-class VariableReference(Literal):
-    """A variable reference node."""
-    __slots__ = ['name']
-    def __init__(self, name):
-        self.name = name
-    def __call__(self, kind, data, pos, namespaces, variables):
-        return variables.get(self.name)
-    def __repr__(self):
-        return str(self.name)
-
-# Operators
-
-class AndOperator(object):
-    """The boolean operator `and`."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        if not lval:
-            return False
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return bool(rval)
-    def __repr__(self):
-        return '%s and %s' % (self.lval, self.rval)
-
-class EqualsOperator(object):
-    """The equality operator `=`."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return lval == rval
-    def __repr__(self):
-        return '%s=%s' % (self.lval, self.rval)
-
-class NotEqualsOperator(object):
-    """The equality operator `!=`."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return lval != rval
-    def __repr__(self):
-        return '%s!=%s' % (self.lval, self.rval)
-
-class OrOperator(object):
-    """The boolean operator `or`."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        if lval:
-            return True
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return bool(rval)
-    def __repr__(self):
-        return '%s or %s' % (self.lval, self.rval)
-
-class GreaterThanOperator(object):
-    """The relational operator `>` (greater than)."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return float(lval) > float(rval)
-    def __repr__(self):
-        return '%s>%s' % (self.lval, self.rval)
-
-class GreaterThanOrEqualOperator(object):
-    """The relational operator `>=` (greater than or equal)."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return float(lval) >= float(rval)
-    def __repr__(self):
-        return '%s>=%s' % (self.lval, self.rval)
-
-class LessThanOperator(object):
-    """The relational operator `<` (less than)."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return float(lval) < float(rval)
-    def __repr__(self):
-        return '%s<%s' % (self.lval, self.rval)
-
-class LessThanOrEqualOperator(object):
-    """The relational operator `<=` (less than or equal)."""
-    __slots__ = ['lval', 'rval']
-    def __init__(self, lval, rval):
-        self.lval = lval
-        self.rval = rval
-    def __call__(self, kind, data, pos, namespaces, variables):
-        lval = self.lval(kind, data, pos, namespaces, variables)
-        rval = self.rval(kind, data, pos, namespaces, variables)
-        return float(lval) <= float(rval)
-    def __repr__(self):
-        return '%s<=%s' % (self.lval, self.rval)
-
-_operator_map = {'=': EqualsOperator, '!=': NotEqualsOperator,
-                 '>': GreaterThanOperator, '>=': GreaterThanOrEqualOperator,
-                 '<': LessThanOperator, '>=': LessThanOrEqualOperator}
-
-
-_DOTSLASHSLASH = (DESCENDANT_OR_SELF, PrincipalTypeTest(None), ())
diff --git a/generator/genshi/template/__init__.py b/generator/genshi/template/__init__.py
deleted file mode 100644
index 310ffc8..0000000
--- a/generator/genshi/template/__init__.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Implementation of the template engine."""
-
-from genshi.template.base import Context, Template, TemplateError, \
-                                 TemplateRuntimeError, TemplateSyntaxError, \
-                                 BadDirectiveError
-from genshi.template.loader import TemplateLoader, TemplateNotFound
-from genshi.template.markup import MarkupTemplate
-from genshi.template.text import TextTemplate
-
-__docformat__ = 'restructuredtext en'
diff --git a/generator/genshi/template/base.py b/generator/genshi/template/base.py
deleted file mode 100644
index 18e2826..0000000
--- a/generator/genshi/template/base.py
+++ /dev/null
@@ -1,454 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Basic templating functionality."""
-
-try:
-    from collections import deque
-except ImportError:
-    class deque(list):
-        def appendleft(self, x): self.insert(0, x)
-        def popleft(self): return self.pop(0)
-import os
-from StringIO import StringIO
-
-from genshi.core import Attrs, Stream, StreamEventKind, START, TEXT, _ensure
-from genshi.input import ParseError
-
-__all__ = ['Context', 'Template', 'TemplateError', 'TemplateRuntimeError',
-           'TemplateSyntaxError', 'BadDirectiveError']
-__docformat__ = 'restructuredtext en'
-
-
-class TemplateError(Exception):
-    """Base exception class for errors related to template processing."""
-
-    def __init__(self, message, filename='<string>', lineno=-1, offset=-1):
-        """Create the exception.
-        
-        :param message: the error message
-        :param filename: the filename of the template
-        :param lineno: the number of line in the template at which the error
-                       occurred
-        :param offset: the column number at which the error occurred
-        """
-        self.msg = message #: the error message string
-        if filename != '<string>' or lineno >= 0:
-            message = '%s (%s, line %d)' % (self.msg, filename, lineno)
-        Exception.__init__(self, message)
-        self.filename = filename #: the name of the template file
-        self.lineno = lineno #: the number of the line containing the error
-        self.offset = offset #: the offset on the line
-
-
-class TemplateSyntaxError(TemplateError):
-    """Exception raised when an expression in a template causes a Python syntax
-    error, or the template is not well-formed.
-    """
-
-    def __init__(self, message, filename='<string>', lineno=-1, offset=-1):
-        """Create the exception
-        
-        :param message: the error message
-        :param filename: the filename of the template
-        :param lineno: the number of line in the template at which the error
-                       occurred
-        :param offset: the column number at which the error occurred
-        """
-        if isinstance(message, SyntaxError) and message.lineno is not None:
-            message = str(message).replace(' (line %d)' % message.lineno, '')
-        TemplateError.__init__(self, message, filename, lineno)
-
-
-class BadDirectiveError(TemplateSyntaxError):
-    """Exception raised when an unknown directive is encountered when parsing
-    a template.
-    
-    An unknown directive is any attribute using the namespace for directives,
-    with a local name that doesn't match any registered directive.
-    """
-
-    def __init__(self, name, filename='<string>', lineno=-1):
-        """Create the exception
-        
-        :param name: the name of the directive
-        :param filename: the filename of the template
-        :param lineno: the number of line in the template at which the error
-                       occurred
-        """
-        TemplateSyntaxError.__init__(self, 'bad directive "%s"' % name,
-                                     filename, lineno)
-
-
-class TemplateRuntimeError(TemplateError):
-    """Exception raised when an the evaluation of a Python expression in a
-    template causes an error.
-    """
-
-
-class Context(object):
-    """Container for template input data.
-    
-    A context provides a stack of scopes (represented by dictionaries).
-    
-    Template directives such as loops can push a new scope on the stack with
-    data that should only be available inside the loop. When the loop
-    terminates, that scope can get popped off the stack again.
-    
-    >>> ctxt = Context(one='foo', other=1)
-    >>> ctxt.get('one')
-    'foo'
-    >>> ctxt.get('other')
-    1
-    >>> ctxt.push(dict(one='frost'))
-    >>> ctxt.get('one')
-    'frost'
-    >>> ctxt.get('other')
-    1
-    >>> ctxt.pop()
-    {'one': 'frost'}
-    >>> ctxt.get('one')
-    'foo'
-    """
-
-    def __init__(self, **data):
-        """Initialize the template context with the given keyword arguments as
-        data.
-        """
-        self.frames = deque([data])
-        self.pop = self.frames.popleft
-        self.push = self.frames.appendleft
-        self._match_templates = []
-
-        # Helper functions for use in expressions
-        def defined(name):
-            """Return whether a variable with the specified name exists in the
-            expression scope."""
-            return name in self
-        def value_of(name, default=None):
-            """If a variable of the specified name is defined, return its value.
-            Otherwise, return the provided default value, or ``None``."""
-            return self.get(name, default)
-        data.setdefault('defined', defined)
-        data.setdefault('value_of', value_of)
-
-    def __repr__(self):
-        return repr(list(self.frames))
-
-    def __contains__(self, key):
-        """Return whether a variable exists in any of the scopes.
-        
-        :param key: the name of the variable
-        """
-        return self._find(key)[1] is not None
-
-    def __delitem__(self, key):
-        """Remove a variable from all scopes.
-        
-        :param key: the name of the variable
-        """
-        for frame in self.frames:
-            if key in frame:
-                del frame[key]
-
-    def __getitem__(self, key):
-        """Get a variables's value, starting at the current scope and going
-        upward.
-        
-        :param key: the name of the variable
-        :return: the variable value
-        :raises KeyError: if the requested variable wasn't found in any scope
-        """
-        value, frame = self._find(key)
-        if frame is None:
-            raise KeyError(key)
-        return value
-
-    def __len__(self):
-        """Return the number of distinctly named variables in the context.
-        
-        :return: the number of variables in the context
-        """
-        return len(self.items())
-
-    def __setitem__(self, key, value):
-        """Set a variable in the current scope.
-        
-        :param key: the name of the variable
-        :param value: the variable value
-        """
-        self.frames[0][key] = value
-
-    def _find(self, key, default=None):
-        """Retrieve a given variable's value and the frame it was found in.
-
-        Intended primarily for internal use by directives.
-        
-        :param key: the name of the variable
-        :param default: the default value to return when the variable is not
-                        found
-        """
-        for frame in self.frames:
-            if key in frame:
-                return frame[key], frame
-        return default, None
-
-    def get(self, key, default=None):
-        """Get a variable's value, starting at the current scope and going
-        upward.
-        
-        :param key: the name of the variable
-        :param default: the default value to return when the variable is not
-                        found
-        """
-        for frame in self.frames:
-            if key in frame:
-                return frame[key]
-        return default
-
-    def keys(self):
-        """Return the name of all variables in the context.
-        
-        :return: a list of variable names
-        """
-        keys = []
-        for frame in self.frames:
-            keys += [key for key in frame if key not in keys]
-        return keys
-
-    def items(self):
-        """Return a list of ``(name, value)`` tuples for all variables in the
-        context.
-        
-        :return: a list of variables
-        """
-        return [(key, self.get(key)) for key in self.keys()]
-
-    def push(self, data):
-        """Push a new scope on the stack.
-        
-        :param data: the data dictionary to push on the context stack.
-        """
-
-    def pop(self):
-        """Pop the top-most scope from the stack."""
-
-
-def _apply_directives(stream, ctxt, directives):
-    """Apply the given directives to the stream.
-    
-    :param stream: the stream the directives should be applied to
-    :param ctxt: the `Context`
-    :param directives: the list of directives to apply
-    :return: the stream with the given directives applied
-    """
-    if directives:
-        stream = directives[0](iter(stream), ctxt, directives[1:])
-    return stream
-
-
-class TemplateMeta(type):
-    """Meta class for templates."""
-
-    def __new__(cls, name, bases, d):
-        if 'directives' in d:
-            d['_dir_by_name'] = dict(d['directives'])
-            d['_dir_order'] = [directive[1] for directive in d['directives']]
-
-        return type.__new__(cls, name, bases, d)
-
-
-class Template(object):
-    """Abstract template base class.
-    
-    This class implements most of the template processing model, but does not
-    specify the syntax of templates.
-    """
-    __metaclass__ = TemplateMeta
-
-    EXPR = StreamEventKind('EXPR')
-    """Stream event kind representing a Python expression."""
-
-    SUB = StreamEventKind('SUB')
-    """Stream event kind representing a nested stream to which one or more
-    directives should be applied.
-    """
-
-    def __init__(self, source, basedir=None, filename=None, loader=None,
-                 encoding=None, lookup='lenient'):
-        """Initialize a template from either a string, a file-like object, or
-        an already parsed markup stream.
-        
-        :param source: a string, file-like object, or markup stream to read the
-                       template from
-        :param basedir: the base directory containing the template file; when
-                        loaded from a `TemplateLoader`, this will be the
-                        directory on the template search path in which the
-                        template was found
-        :param filename: the name of the template file, relative to the given
-                         base directory
-        :param loader: the `TemplateLoader` to use for load included templates
-        :param encoding: the encoding of the `source`
-        :param lookup: the variable lookup mechanism; either "lenient" (the
-                       default), "strict", or a custom lookup class
-        """
-        self.basedir = basedir
-        self.filename = filename
-        if basedir and filename:
-            self.filepath = os.path.join(basedir, filename)
-        else:
-            self.filepath = filename
-        self.loader = loader
-        self.lookup = lookup
-
-        if isinstance(source, basestring):
-            source = StringIO(source)
-        else:
-            source = source
-        try:
-            self.stream = list(self._prepare(self._parse(source, encoding)))
-        except ParseError, e:
-            raise TemplateSyntaxError(e.msg, self.filepath, e.lineno, e.offset)
-        self.filters = [self._flatten, self._eval]
-
-    def __repr__(self):
-        return '<%s "%s">' % (self.__class__.__name__, self.filename)
-
-    def _parse(self, source, encoding):
-        """Parse the template.
-        
-        The parsing stage parses the template and constructs a list of
-        directives that will be executed in the render stage. The input is
-        split up into literal output (text that does not depend on the context
-        data) and directives or expressions.
-        
-        :param source: a file-like object containing the XML source of the
-                       template, or an XML event stream
-        :param encoding: the encoding of the `source`
-        """
-        raise NotImplementedError
-
-    def _prepare(self, stream):
-        """Call the `attach` method of every directive found in the template.
-        
-        :param stream: the event stream of the template
-        """
-        for kind, data, pos in stream:
-            if kind is SUB:
-                directives = []
-                substream = data[1]
-                for cls, value, namespaces, pos in data[0]:
-                    directive, substream = cls.attach(self, substream, value,
-                                                      namespaces, pos)
-                    if directive:
-                        directives.append(directive)
-                substream = self._prepare(substream)
-                if directives:
-                    yield kind, (directives, list(substream)), pos
-                else:
-                    for event in substream:
-                        yield event
-            else:
-                yield kind, data, pos
-
-    def generate(self, *args, **kwargs):
-        """Apply the template to the given context data.
-        
-        Any keyword arguments are made available to the template as context
-        data.
-        
-        Only one positional argument is accepted: if it is provided, it must be
-        an instance of the `Context` class, and keyword arguments are ignored.
-        This calling style is used for internal processing.
-        
-        :return: a markup event stream representing the result of applying
-                 the template to the context data.
-        """
-        if args:
-            assert len(args) == 1
-            ctxt = args[0]
-            if ctxt is None:
-                ctxt = Context(**kwargs)
-            assert isinstance(ctxt, Context)
-        else:
-            ctxt = Context(**kwargs)
-
-        stream = self.stream
-        for filter_ in self.filters:
-            stream = filter_(iter(stream), ctxt)
-        return Stream(stream)
-
-    def _eval(self, stream, ctxt):
-        """Internal stream filter that evaluates any expressions in `START` and
-        `TEXT` events.
-        """
-        filters = (self._flatten, self._eval)
-
-        for kind, data, pos in stream:
-
-            if kind is START and data[1]:
-                # Attributes may still contain expressions in start tags at
-                # this point, so do some evaluation
-                tag, attrs = data
-                new_attrs = []
-                for name, substream in attrs:
-                    if isinstance(substream, basestring):
-                        value = substream
-                    else:
-                        values = []
-                        for subkind, subdata, subpos in self._eval(substream,
-                                                                   ctxt):
-                            if subkind is TEXT:
-                                values.append(subdata)
-                        value = [x for x in values if x is not None]
-                        if not value:
-                            continue
-                    new_attrs.append((name, u''.join(value)))
-                yield kind, (tag, Attrs(new_attrs)), pos
-
-            elif kind is EXPR:
-                result = data.evaluate(ctxt)
-                if result is not None:
-                    # First check for a string, otherwise the iterable test below
-                    # succeeds, and the string will be chopped up into individual
-                    # characters
-                    if isinstance(result, basestring):
-                        yield TEXT, result, pos
-                    elif hasattr(result, '__iter__'):
-                        substream = _ensure(result)
-                        for filter_ in filters:
-                            substream = filter_(substream, ctxt)
-                        for event in substream:
-                            yield event
-                    else:
-                        yield TEXT, unicode(result), pos
-
-            else:
-                yield kind, data, pos
-
-    def _flatten(self, stream, ctxt):
-        """Internal stream filter that expands `SUB` events in the stream."""
-        for event in stream:
-            if event[0] is SUB:
-                # This event is a list of directives and a list of nested
-                # events to which those directives should be applied
-                directives, substream = event[1]
-                substream = _apply_directives(substream, ctxt, directives)
-                for event in self._flatten(substream, ctxt):
-                    yield event
-            else:
-                yield event
-
-
-EXPR = Template.EXPR
-SUB = Template.SUB
diff --git a/generator/genshi/template/directives.py b/generator/genshi/template/directives.py
deleted file mode 100644
index c1b1c63..0000000
--- a/generator/genshi/template/directives.py
+++ /dev/null
@@ -1,678 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Implementation of the various template directives."""
-
-import compiler
-
-from genshi.core import Attrs, QName, Stream
-from genshi.path import Path
-from genshi.template.base import TemplateRuntimeError, TemplateSyntaxError, \
-                                 EXPR, _apply_directives
-from genshi.template.eval import Expression, _parse
-
-__all__ = ['AttrsDirective', 'ChooseDirective', 'ContentDirective',
-           'DefDirective', 'ForDirective', 'IfDirective', 'MatchDirective',
-           'OtherwiseDirective', 'ReplaceDirective', 'StripDirective',
-           'WhenDirective', 'WithDirective']
-__docformat__ = 'restructuredtext en'
-
-
-class DirectiveMeta(type):
-    """Meta class for template directives."""
-
-    def __new__(cls, name, bases, d):
-        d['tagname'] = name.lower().replace('directive', '')
-        return type.__new__(cls, name, bases, d)
-
-
-class Directive(object):
-    """Abstract base class for template directives.
-    
-    A directive is basically a callable that takes three positional arguments:
-    ``ctxt`` is the template data context, ``stream`` is an iterable over the
-    events that the directive applies to, and ``directives`` is is a list of
-    other directives on the same stream that need to be applied.
-    
-    Directives can be "anonymous" or "registered". Registered directives can be
-    applied by the template author using an XML attribute with the
-    corresponding name in the template. Such directives should be subclasses of
-    this base class that can  be instantiated with the value of the directive
-    attribute as parameter.
-    
-    Anonymous directives are simply functions conforming to the protocol
-    described above, and can only be applied programmatically (for example by
-    template filters).
-    """
-    __metaclass__ = DirectiveMeta
-    __slots__ = ['expr']
-
-    def __init__(self, value, template=None, namespaces=None, lineno=-1,
-                 offset=-1):
-        self.expr = self._parse_expr(value, template, lineno, offset)
-
-    def attach(cls, template, stream, value, namespaces, pos):
-        """Called after the template stream has been completely parsed.
-        
-        :param template: the `Template` object
-        :param stream: the event stream associated with the directive
-        :param value: the argument value for the directive
-        :param namespaces: a mapping of namespace URIs to prefixes
-        :param pos: a ``(filename, lineno, offset)`` tuple describing the
-                    location where the directive was found in the source
-        
-        This class method should return a ``(directive, stream)`` tuple. If
-        ``directive`` is not ``None``, it should be an instance of the `Directive`
-        class, and gets added to the list of directives applied to the substream
-        at runtime. `stream` is an event stream that replaces the original
-        stream associated with the directive.
-        """
-        return cls(value, template, namespaces, *pos[1:]), stream
-    attach = classmethod(attach)
-
-    def __call__(self, stream, ctxt, directives):
-        """Apply the directive to the given stream.
-        
-        :param stream: the event stream
-        :param ctxt: the context data
-        :param directives: a list of the remaining directives that should
-                           process the stream
-        """
-        raise NotImplementedError
-
-    def __repr__(self):
-        expr = ''
-        if getattr(self, 'expr', None) is not None:
-            expr = ' "%s"' % self.expr.source
-        return '<%s%s>' % (self.__class__.__name__, expr)
-
-    def _parse_expr(cls, expr, template, lineno=-1, offset=-1):
-        """Parses the given expression, raising a useful error message when a
-        syntax error is encountered.
-        """
-        try:
-            return expr and Expression(expr, template.filepath, lineno,
-                                       lookup=template.lookup) or None
-        except SyntaxError, err:
-            err.msg += ' in expression "%s" of "%s" directive' % (expr,
-                                                                  cls.tagname)
-            raise TemplateSyntaxError(err, template.filepath, lineno,
-                                      offset + (err.offset or 0))
-    _parse_expr = classmethod(_parse_expr)
-
-
-def _assignment(ast):
-    """Takes the AST representation of an assignment, and returns a function
-    that applies the assignment of a given value to a dictionary.
-    """
-    def _names(node):
-        if isinstance(node, (compiler.ast.AssTuple, compiler.ast.Tuple)):
-            return tuple([_names(child) for child in node.nodes])
-        elif isinstance(node, (compiler.ast.AssName, compiler.ast.Name)):
-            return node.name
-    def _assign(data, value, names=_names(ast)):
-        if type(names) is tuple:
-            for idx in range(len(names)):
-                _assign(data, value[idx], names[idx])
-        else:
-            data[names] = value
-    return _assign
-
-
-class AttrsDirective(Directive):
-    """Implementation of the ``py:attrs`` template directive.
-    
-    The value of the ``py:attrs`` attribute should be a dictionary or a sequence
-    of ``(name, value)`` tuples. The items in that dictionary or sequence are
-    added as attributes to the element:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
-    ...   <li py:attrs="foo">Bar</li>
-    ... </ul>''')
-    >>> print tmpl.generate(foo={'class': 'collapse'})
-    <ul>
-      <li class="collapse">Bar</li>
-    </ul>
-    >>> print tmpl.generate(foo=[('class', 'collapse')])
-    <ul>
-      <li class="collapse">Bar</li>
-    </ul>
-    
-    If the value evaluates to ``None`` (or any other non-truth value), no
-    attributes are added:
-    
-    >>> print tmpl.generate(foo=None)
-    <ul>
-      <li>Bar</li>
-    </ul>
-    """
-    __slots__ = []
-
-    def __call__(self, stream, ctxt, directives):
-        def _generate():
-            kind, (tag, attrib), pos  = stream.next()
-            attrs = self.expr.evaluate(ctxt)
-            if attrs:
-                if isinstance(attrs, Stream):
-                    try:
-                        attrs = iter(attrs).next()
-                    except StopIteration:
-                        attrs = []
-                elif not isinstance(attrs, list): # assume it's a dict
-                    attrs = attrs.items()
-                attrib -= [name for name, val in attrs if val is None]
-                attrib |= [(QName(name), unicode(val).strip()) for name, val
-                           in attrs if val is not None]
-            yield kind, (tag, attrib), pos
-            for event in stream:
-                yield event
-
-        return _apply_directives(_generate(), ctxt, directives)
-
-
-class ContentDirective(Directive):
-    """Implementation of the ``py:content`` template directive.
-    
-    This directive replaces the content of the element with the result of
-    evaluating the value of the ``py:content`` attribute:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
-    ...   <li py:content="bar">Hello</li>
-    ... </ul>''')
-    >>> print tmpl.generate(bar='Bye')
-    <ul>
-      <li>Bye</li>
-    </ul>
-    """
-    __slots__ = []
-
-    def attach(cls, template, stream, value, namespaces, pos):
-        expr = cls._parse_expr(value, template, *pos[1:])
-        return None, [stream[0], (EXPR, expr, pos),  stream[-1]]
-    attach = classmethod(attach)
-
-
-class DefDirective(Directive):
-    """Implementation of the ``py:def`` template directive.
-    
-    This directive can be used to create "Named Template Functions", which
-    are template snippets that are not actually output during normal
-    processing, but rather can be expanded from expressions in other places
-    in the template.
-    
-    A named template function can be used just like a normal Python function
-    from template expressions:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <p py:def="echo(greeting, name='world')" class="message">
-    ...     ${greeting}, ${name}!
-    ...   </p>
-    ...   ${echo('Hi', name='you')}
-    ... </div>''')
-    >>> print tmpl.generate(bar='Bye')
-    <div>
-      <p class="message">
-        Hi, you!
-      </p>
-    </div>
-    
-    If a function does not require parameters, the parenthesis can be omitted
-    in the definition:
-    
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <p py:def="helloworld" class="message">
-    ...     Hello, world!
-    ...   </p>
-    ...   ${helloworld()}
-    ... </div>''')
-    >>> print tmpl.generate(bar='Bye')
-    <div>
-      <p class="message">
-        Hello, world!
-      </p>
-    </div>
-    """
-    __slots__ = ['name', 'args', 'defaults']
-
-    ATTRIBUTE = 'function'
-
-    def __init__(self, args, template, namespaces=None, lineno=-1, offset=-1):
-        Directive.__init__(self, None, template, namespaces, lineno, offset)
-        ast = _parse(args).node
-        self.args = []
-        self.defaults = {}
-        if isinstance(ast, compiler.ast.CallFunc):
-            self.name = ast.node.name
-            for arg in ast.args:
-                if isinstance(arg, compiler.ast.Keyword):
-                    self.args.append(arg.name)
-                    self.defaults[arg.name] = Expression(arg.expr,
-                                                         template.filepath,
-                                                         lineno,
-                                                         lookup=template.lookup)
-                else:
-                    self.args.append(arg.name)
-        else:
-            self.name = ast.name
-
-    def __call__(self, stream, ctxt, directives):
-        stream = list(stream)
-
-        def function(*args, **kwargs):
-            scope = {}
-            args = list(args) # make mutable
-            for name in self.args:
-                if args:
-                    scope[name] = args.pop(0)
-                else:
-                    if name in kwargs:
-                        val = kwargs.pop(name)
-                    else:
-                        val = self.defaults.get(name).evaluate(ctxt)
-                    scope[name] = val
-            ctxt.push(scope)
-            for event in _apply_directives(stream, ctxt, directives):
-                yield event
-            ctxt.pop()
-        try:
-            function.__name__ = self.name
-        except TypeError:
-            # Function name can't be set in Python 2.3 
-            pass
-
-        # Store the function reference in the bottom context frame so that it
-        # doesn't get popped off before processing the template has finished
-        # FIXME: this makes context data mutable as a side-effect
-        ctxt.frames[-1][self.name] = function
-
-        return []
-
-    def __repr__(self):
-        return '<%s "%s">' % (self.__class__.__name__, self.name)
-
-
-class ForDirective(Directive):
-    """Implementation of the ``py:for`` template directive for repeating an
-    element based on an iterable in the context data.
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
-    ...   <li py:for="item in items">${item}</li>
-    ... </ul>''')
-    >>> print tmpl.generate(items=[1, 2, 3])
-    <ul>
-      <li>1</li><li>2</li><li>3</li>
-    </ul>
-    """
-    __slots__ = ['assign', 'filename']
-
-    ATTRIBUTE = 'each'
-
-    def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
-        if ' in ' not in value:
-            raise TemplateSyntaxError('"in" keyword missing in "for" directive',
-                                      template.filepath, lineno, offset)
-        assign, value = value.split(' in ', 1)
-        ast = _parse(assign, 'exec')
-        self.assign = _assignment(ast.node.nodes[0].expr)
-        self.filename = template.filepath
-        Directive.__init__(self, value.strip(), template, namespaces, lineno,
-                           offset)
-
-    def __call__(self, stream, ctxt, directives):
-        iterable = self.expr.evaluate(ctxt)
-        if iterable is None:
-            return
-
-        assign = self.assign
-        scope = {}
-        stream = list(stream)
-        try:
-            iterator = iter(iterable)
-            for item in iterator:
-                assign(scope, item)
-                ctxt.push(scope)
-                for event in _apply_directives(stream, ctxt, directives):
-                    yield event
-                ctxt.pop()
-        except TypeError, e:
-            raise TemplateRuntimeError(str(e), self.filename, *stream[0][2][1:])
-
-    def __repr__(self):
-        return '<%s>' % self.__class__.__name__
-
-
-class IfDirective(Directive):
-    """Implementation of the ``py:if`` template directive for conditionally
-    excluding elements from being output.
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <b py:if="foo">${bar}</b>
-    ... </div>''')
-    >>> print tmpl.generate(foo=True, bar='Hello')
-    <div>
-      <b>Hello</b>
-    </div>
-    """
-    __slots__ = []
-
-    ATTRIBUTE = 'test'
-
-    def __call__(self, stream, ctxt, directives):
-        if self.expr.evaluate(ctxt):
-            return _apply_directives(stream, ctxt, directives)
-        return []
-
-
-class MatchDirective(Directive):
-    """Implementation of the ``py:match`` template directive.
-
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <span py:match="greeting">
-    ...     Hello ${select('@name')}
-    ...   </span>
-    ...   <greeting name="Dude" />
-    ... </div>''')
-    >>> print tmpl.generate()
-    <div>
-      <span>
-        Hello Dude
-      </span>
-    </div>
-    """
-    __slots__ = ['path', 'namespaces']
-
-    ATTRIBUTE = 'path'
-
-    def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
-        Directive.__init__(self, None, template, namespaces, lineno, offset)
-        self.path = Path(value, template.filepath, lineno)
-        self.namespaces = namespaces or {}
-
-    def __call__(self, stream, ctxt, directives):
-        ctxt._match_templates.append((self.path.test(ignore_context=True),
-                                      self.path, list(stream), self.namespaces,
-                                      directives))
-        return []
-
-    def __repr__(self):
-        return '<%s "%s">' % (self.__class__.__name__, self.path.source)
-
-
-class ReplaceDirective(Directive):
-    """Implementation of the ``py:replace`` template directive.
-    
-    This directive replaces the element with the result of evaluating the
-    value of the ``py:replace`` attribute:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <span py:replace="bar">Hello</span>
-    ... </div>''')
-    >>> print tmpl.generate(bar='Bye')
-    <div>
-      Bye
-    </div>
-    
-    This directive is equivalent to ``py:content`` combined with ``py:strip``,
-    providing a less verbose way to achieve the same effect:
-    
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <span py:content="bar" py:strip="">Hello</span>
-    ... </div>''')
-    >>> print tmpl.generate(bar='Bye')
-    <div>
-      Bye
-    </div>
-    """
-    __slots__ = []
-
-    def attach(cls, template, stream, value, namespaces, pos):
-        if not value:
-            raise TemplateSyntaxError('missing value for "replace" directive',
-                                      template.filepath, *pos[1:])
-        expr = cls._parse_expr(value, template, *pos[1:])
-        return None, [(EXPR, expr, pos)]
-    attach = classmethod(attach)
-
-
-class StripDirective(Directive):
-    """Implementation of the ``py:strip`` template directive.
-    
-    When the value of the ``py:strip`` attribute evaluates to ``True``, the
-    element is stripped from the output
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <div py:strip="True"><b>foo</b></div>
-    ... </div>''')
-    >>> print tmpl.generate()
-    <div>
-      <b>foo</b>
-    </div>
-    
-    Leaving the attribute value empty is equivalent to a truth value.
-    
-    This directive is particulary interesting for named template functions or
-    match templates that do not generate a top-level element:
-    
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <div py:def="echo(what)" py:strip="">
-    ...     <b>${what}</b>
-    ...   </div>
-    ...   ${echo('foo')}
-    ... </div>''')
-    >>> print tmpl.generate()
-    <div>
-        <b>foo</b>
-    </div>
-    """
-    __slots__ = []
-
-    def __call__(self, stream, ctxt, directives):
-        def _generate():
-            if self.expr.evaluate(ctxt):
-                stream.next() # skip start tag
-                previous = stream.next()
-                for event in stream:
-                    yield previous
-                    previous = event
-            else:
-                for event in stream:
-                    yield event
-        return _apply_directives(_generate(), ctxt, directives)
-
-    def attach(cls, template, stream, value, namespaces, pos):
-        if not value:
-            return None, stream[1:-1]
-        return super(StripDirective, cls).attach(template, stream, value,
-                                                 namespaces, pos)
-    attach = classmethod(attach)
-
-
-class ChooseDirective(Directive):
-    """Implementation of the ``py:choose`` directive for conditionally selecting
-    one of several body elements to display.
-    
-    If the ``py:choose`` expression is empty the expressions of nested
-    ``py:when`` directives are tested for truth.  The first true ``py:when``
-    body is output. If no ``py:when`` directive is matched then the fallback
-    directive ``py:otherwise`` will be used.
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/"
-    ...   py:choose="">
-    ...   <span py:when="0 == 1">0</span>
-    ...   <span py:when="1 == 1">1</span>
-    ...   <span py:otherwise="">2</span>
-    ... </div>''')
-    >>> print tmpl.generate()
-    <div>
-      <span>1</span>
-    </div>
-    
-    If the ``py:choose`` directive contains an expression, the nested
-    ``py:when`` directives are tested for equality to the ``py:choose``
-    expression:
-    
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/"
-    ...   py:choose="2">
-    ...   <span py:when="1">1</span>
-    ...   <span py:when="2">2</span>
-    ... </div>''')
-    >>> print tmpl.generate()
-    <div>
-      <span>2</span>
-    </div>
-    
-    Behavior is undefined if a ``py:choose`` block contains content outside a
-    ``py:when`` or ``py:otherwise`` block.  Behavior is also undefined if a
-    ``py:otherwise`` occurs before ``py:when`` blocks.
-    """
-    __slots__ = ['matched', 'value']
-
-    ATTRIBUTE = 'test'
-
-    def __call__(self, stream, ctxt, directives):
-        frame = dict({'_choose.matched': False})
-        if self.expr:
-            frame['_choose.value'] = self.expr.evaluate(ctxt)
-        ctxt.push(frame)
-        for event in _apply_directives(stream, ctxt, directives):
-            yield event
-        ctxt.pop()
-
-
-class WhenDirective(Directive):
-    """Implementation of the ``py:when`` directive for nesting in a parent with
-    the ``py:choose`` directive.
-    
-    See the documentation of the `ChooseDirective` for usage.
-    """
-    __slots__ = ['filename']
-
-    ATTRIBUTE = 'test'
-
-    def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
-        Directive.__init__(self, value, template, namespaces, lineno, offset)
-        self.filename = template.filepath
-
-    def __call__(self, stream, ctxt, directives):
-        matched, frame = ctxt._find('_choose.matched')
-        if not frame:
-            raise TemplateRuntimeError('"when" directives can only be used '
-                                       'inside a "choose" directive',
-                                       self.filename, *stream.next()[2][1:])
-        if matched:
-            return []
-        if not self.expr and '_choose.value' not in frame:
-            raise TemplateRuntimeError('either "choose" or "when" directive '
-                                       'must have a test expression',
-                                       self.filename, *stream.next()[2][1:])
-        if '_choose.value' in frame:
-            value = frame['_choose.value']
-            if self.expr:
-                matched = value == self.expr.evaluate(ctxt)
-            else:
-                matched = bool(value)
-        else:
-            matched = bool(self.expr.evaluate(ctxt))
-        frame['_choose.matched'] = matched
-        if not matched:
-            return []
-
-        return _apply_directives(stream, ctxt, directives)
-
-
-class OtherwiseDirective(Directive):
-    """Implementation of the ``py:otherwise`` directive for nesting in a parent
-    with the ``py:choose`` directive.
-    
-    See the documentation of `ChooseDirective` for usage.
-    """
-    __slots__ = ['filename']
-
-    def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
-        Directive.__init__(self, None, template, namespaces, lineno, offset)
-        self.filename = template.filepath
-
-    def __call__(self, stream, ctxt, directives):
-        matched, frame = ctxt._find('_choose.matched')
-        if not frame:
-            raise TemplateRuntimeError('an "otherwise" directive can only be '
-                                       'used inside a "choose" directive',
-                                       self.filename, *stream.next()[2][1:])
-        if matched:
-            return []
-        frame['_choose.matched'] = True
-
-        return _apply_directives(stream, ctxt, directives)
-
-
-class WithDirective(Directive):
-    """Implementation of the ``py:with`` template directive, which allows
-    shorthand access to variables and expressions.
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> tmpl = MarkupTemplate('''<div xmlns:py="http://genshi.edgewall.org/">
-    ...   <span py:with="y=7; z=x+10">$x $y $z</span>
-    ... </div>''')
-    >>> print tmpl.generate(x=42)
-    <div>
-      <span>42 7 52</span>
-    </div>
-    """
-    __slots__ = ['vars']
-
-    ATTRIBUTE = 'vars'
-
-    def __init__(self, value, template, namespaces=None, lineno=-1, offset=-1):
-        Directive.__init__(self, None, template, namespaces, lineno, offset)
-        self.vars = []
-        value = value.strip()
-        try:
-            ast = _parse(value, 'exec').node
-            for node in ast.nodes:
-                if isinstance(node, compiler.ast.Discard):
-                    continue
-                elif not isinstance(node, compiler.ast.Assign):
-                    raise TemplateSyntaxError('only assignment allowed in '
-                                              'value of the "with" directive',
-                                              template.filepath, lineno, offset)
-                self.vars.append(([_assignment(n) for n in node.nodes],
-                                  Expression(node.expr, template.filepath,
-                                             lineno, lookup=template.lookup)))
-        except SyntaxError, err:
-            err.msg += ' in expression "%s" of "%s" directive' % (value,
-                                                                  self.tagname)
-            raise TemplateSyntaxError(err, template.filepath, lineno,
-                                      offset + (err.offset or 0))
-
-    def __call__(self, stream, ctxt, directives):
-        frame = {}
-        ctxt.push(frame)
-        for targets, expr in self.vars:
-            value = expr.evaluate(ctxt)
-            for assign in targets:
-                assign(frame, value)
-        for event in _apply_directives(stream, ctxt, directives):
-            yield event
-        ctxt.pop()
-
-    def __repr__(self):
-        return '<%s>' % (self.__class__.__name__)
diff --git a/generator/genshi/template/eval.py b/generator/genshi/template/eval.py
deleted file mode 100644
index 938d906..0000000
--- a/generator/genshi/template/eval.py
+++ /dev/null
@@ -1,710 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Support for "safe" evaluation of Python expressions."""
-
-import __builtin__
-from compiler import ast, parse
-from compiler.pycodegen import ExpressionCodeGenerator, ModuleCodeGenerator
-import new
-try:
-    set
-except NameError:
-    from sets import Set as set
-import sys
-
-from genshi.core import Markup
-from genshi.template.base import TemplateRuntimeError
-from genshi.util import flatten
-
-__all__ = ['Code', 'Expression', 'Suite', 'LenientLookup', 'StrictLookup',
-           'Undefined', 'UndefinedError']
-__docformat__ = 'restructuredtext en'
-
-
-class Code(object):
-    """Abstract base class for the `Expression` and `Suite` classes."""
-    __slots__ = ['source', 'code', '_globals']
-
-    def __init__(self, source, filename=None, lineno=-1, lookup='lenient'):
-        """Create the code object, either from a string, or from an AST node.
-        
-        :param source: either a string containing the source code, or an AST
-                       node
-        :param filename: the (preferably absolute) name of the file containing
-                         the code
-        :param lineno: the number of the line on which the code was found
-        :param lookup: the lookup class that defines how variables are looked
-                       up in the context. Can be either `LenientLookup` (the
-                       default), `StrictLookup`, or a custom lookup class
-        """
-        if isinstance(source, basestring):
-            self.source = source
-            node = _parse(source, mode=self.mode)
-        else:
-            assert isinstance(source, ast.Node)
-            self.source = '?'
-            if self.mode == 'eval':
-                node = ast.Expression(source)
-            else:
-                node = ast.Module(None, source)
-
-        self.code = _compile(node, self.source, mode=self.mode,
-                             filename=filename, lineno=lineno)
-        if lookup is None:
-            lookup = LenientLookup
-        elif isinstance(lookup, basestring):
-            lookup = {'lenient': LenientLookup, 'strict': StrictLookup}[lookup]
-        self._globals = lookup.globals()
-
-    def __eq__(self, other):
-        return (type(other) == type(self)) and (self.code == other.code)
-
-    def __hash__(self):
-        return hash(self.code)
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __repr__(self):
-        return '%s(%r)' % (self.__class__.__name__, self.source)
-
-
-class Expression(Code):
-    """Evaluates Python expressions used in templates.
-
-    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
-    >>> Expression('test').evaluate(data)
-    'Foo'
-
-    >>> Expression('items[0]').evaluate(data)
-    1
-    >>> Expression('items[-1]').evaluate(data)
-    3
-    >>> Expression('dict["some"]').evaluate(data)
-    'thing'
-    
-    Similar to e.g. Javascript, expressions in templates can use the dot
-    notation for attribute access to access items in mappings:
-    
-    >>> Expression('dict.some').evaluate(data)
-    'thing'
-    
-    This also works the other way around: item access can be used to access
-    any object attribute:
-    
-    >>> class MyClass(object):
-    ...     myattr = 'Bar'
-    >>> data = dict(mine=MyClass(), key='myattr')
-    >>> Expression('mine.myattr').evaluate(data)
-    'Bar'
-    >>> Expression('mine["myattr"]').evaluate(data)
-    'Bar'
-    >>> Expression('mine[key]').evaluate(data)
-    'Bar'
-    
-    All of the standard Python operators are available to template expressions.
-    Built-in functions such as ``len()`` are also available in template
-    expressions:
-    
-    >>> data = dict(items=[1, 2, 3])
-    >>> Expression('len(items)').evaluate(data)
-    3
-    """
-    __slots__ = []
-    mode = 'eval'
-
-    def evaluate(self, data):
-        """Evaluate the expression against the given data dictionary.
-        
-        :param data: a mapping containing the data to evaluate against
-        :return: the result of the evaluation
-        """
-        __traceback_hide__ = 'before_and_this'
-        _globals = self._globals
-        _globals['data'] = data
-        return eval(self.code, _globals, {'data': data})
-
-
-class Suite(Code):
-    """Executes Python statements used in templates.
-
-    >>> data = dict(test='Foo', items=[1, 2, 3], dict={'some': 'thing'})
-    >>> Suite('foo = dict.some').execute(data)
-    >>> data['foo']
-    'thing'
-    """
-    __slots__ = []
-    mode = 'exec'
-
-    def execute(self, data):
-        """Execute the suite in the given data dictionary.
-        
-        :param data: a mapping containing the data to execute in
-        """
-        __traceback_hide__ = 'before_and_this'
-        _globals = self._globals
-        _globals['data'] = data
-        exec self.code in _globals, data
-
-
-UNDEFINED = object()
-
-
-class UndefinedError(TemplateRuntimeError):
-    """Exception thrown when a template expression attempts to access a variable
-    not defined in the context.
-    
-    :see: `LenientLookup`, `StrictLookup`
-    """
-    def __init__(self, name, owner=UNDEFINED):
-        if owner is not UNDEFINED:
-            message = '%s has no member named "%s"' % (repr(owner), name)
-        else:
-            message = '"%s" not defined' % name
-        TemplateRuntimeError.__init__(self, message)
-
-
-class Undefined(object):
-    """Represents a reference to an undefined variable.
-    
-    Unlike the Python runtime, template expressions can refer to an undefined
-    variable without causing a `NameError` to be raised. The result will be an
-    instance of the `Undefined` class, which is treated the same as ``False`` in
-    conditions, but raise an exception on any other operation:
-    
-    >>> foo = Undefined('foo')
-    >>> bool(foo)
-    False
-    >>> list(foo)
-    []
-    >>> print foo
-    undefined
-    
-    However, calling an undefined variable, or trying to access an attribute
-    of that variable, will raise an exception that includes the name used to
-    reference that undefined variable.
-    
-    >>> foo('bar')
-    Traceback (most recent call last):
-        ...
-    UndefinedError: "foo" not defined
-
-    >>> foo.bar
-    Traceback (most recent call last):
-        ...
-    UndefinedError: "foo" not defined
-    
-    :see: `LenientLookup`
-    """
-    __slots__ = ['_name', '_owner']
-
-    def __init__(self, name, owner=UNDEFINED):
-        """Initialize the object.
-        
-        :param name: the name of the reference
-        :param owner: the owning object, if the variable is accessed as a member
-        """
-        self._name = name
-        self._owner = owner
-
-    def __iter__(self):
-        return iter([])
-
-    def __nonzero__(self):
-        return False
-
-    def __repr__(self):
-        return '<%s %r>' % (self.__class__.__name__, self._name)
-
-    def __str__(self):
-        return 'undefined'
-
-    def _die(self, *args, **kwargs):
-        """Raise an `UndefinedError`."""
-        __traceback_hide__ = True
-        raise UndefinedError(self._name, self._owner)
-    __call__ = __getattr__ = __getitem__ = _die
-
-
-class LookupBase(object):
-    """Abstract base class for variable lookup implementations."""
-
-    def globals(cls):
-        """Construct the globals dictionary to use as the execution context for
-        the expression or suite.
-        """
-        return {
-            '_lookup_name': cls.lookup_name,
-            '_lookup_attr': cls.lookup_attr,
-            '_lookup_item': cls.lookup_item
-        }
-    globals = classmethod(globals)
-
-    def lookup_name(cls, data, name):
-        __traceback_hide__ = True
-        val = data.get(name, UNDEFINED)
-        if val is UNDEFINED:
-            val = BUILTINS.get(name, val)
-            if val is UNDEFINED:
-                return cls.undefined(name)
-        return val
-    lookup_name = classmethod(lookup_name)
-
-    def lookup_attr(cls, data, obj, key):
-        __traceback_hide__ = True
-        if hasattr(obj, key):
-            return getattr(obj, key)
-        try:
-            return obj[key]
-        except (KeyError, TypeError):
-            return cls.undefined(key, owner=obj)
-    lookup_attr = classmethod(lookup_attr)
-
-    def lookup_item(cls, data, obj, key):
-        __traceback_hide__ = True
-        if len(key) == 1:
-            key = key[0]
-        try:
-            return obj[key]
-        except (AttributeError, KeyError, IndexError, TypeError), e:
-            if isinstance(key, basestring):
-                val = getattr(obj, key, UNDEFINED)
-                if val is UNDEFINED:
-                    return cls.undefined(key, owner=obj)
-                return val
-            raise
-    lookup_item = classmethod(lookup_item)
-
-    def undefined(cls, key, owner=UNDEFINED):
-        """Can be overridden by subclasses to specify behavior when undefined
-        variables are accessed.
-        
-        :param key: the name of the variable
-        :param owner: the owning object, if the variable is accessed as a member
-        """
-        raise NotImplementedError
-    undefined = classmethod(undefined)
-
-
-class LenientLookup(LookupBase):
-    """Default variable lookup mechanism for expressions.
-    
-    When an undefined variable is referenced using this lookup style, the
-    reference evaluates to an instance of the `Undefined` class:
-    
-    >>> expr = Expression('nothing', lookup='lenient')
-    >>> undef = expr.evaluate({})
-    >>> undef
-    <Undefined 'nothing'>
-    
-    The same will happen when a non-existing attribute or item is accessed on
-    an existing object:
-    
-    >>> expr = Expression('something.nil', lookup='lenient')
-    >>> expr.evaluate({'something': dict()})
-    <Undefined 'nil'>
-    
-    See the documentation of the `Undefined` class for details on the behavior
-    of such objects.
-    
-    :see: `StrictLookup`
-    """
-    def undefined(cls, key, owner=UNDEFINED):
-        """Return an ``Undefined`` object."""
-        __traceback_hide__ = True
-        return Undefined(key, owner=owner)
-    undefined = classmethod(undefined)
-
-
-class StrictLookup(LookupBase):
-    """Strict variable lookup mechanism for expressions.
-    
-    Referencing an undefined variable using this lookup style will immediately
-    raise an ``UndefinedError``:
-    
-    >>> expr = Expression('nothing', lookup='strict')
-    >>> expr.evaluate({})
-    Traceback (most recent call last):
-        ...
-    UndefinedError: "nothing" not defined
-    
-    The same happens when a non-existing attribute or item is accessed on an
-    existing object:
-    
-    >>> expr = Expression('something.nil', lookup='strict')
-    >>> expr.evaluate({'something': dict()})
-    Traceback (most recent call last):
-        ...
-    UndefinedError: {} has no member named "nil"
-    """
-    def undefined(cls, key, owner=UNDEFINED):
-        """Raise an ``UndefinedError`` immediately."""
-        __traceback_hide__ = True
-        raise UndefinedError(key, owner=owner)
-    undefined = classmethod(undefined)
-
-
-def _parse(source, mode='eval'):
-    if isinstance(source, unicode):
-        source = '\xef\xbb\xbf' + source.encode('utf-8')
-    return parse(source, mode)
-
-def _compile(node, source=None, mode='eval', filename=None, lineno=-1):
-    tree = TemplateASTTransformer().visit(node)
-    if isinstance(filename, unicode):
-        # unicode file names not allowed for code objects
-        filename = filename.encode('utf-8', 'replace')
-    elif not filename:
-        filename = '<string>'
-    tree.filename = filename
-    if lineno <= 0:
-        lineno = 1
-
-    if mode == 'eval':
-        gen = ExpressionCodeGenerator(tree)
-        name = '<Expression %s>' % (repr(source or '?'))
-    else:
-        gen = ModuleCodeGenerator(tree)
-        name = '<Suite>'
-    gen.optimized = True
-    code = gen.getCode()
-
-    # We'd like to just set co_firstlineno, but it's readonly. So we need to
-    # clone the code object while adjusting the line number
-    return new.code(0, code.co_nlocals, code.co_stacksize,
-                    code.co_flags | 0x0040, code.co_code, code.co_consts,
-                    code.co_names, code.co_varnames, filename, name, lineno,
-                    code.co_lnotab, (), ())
-
-BUILTINS = __builtin__.__dict__.copy()
-BUILTINS.update({'Markup': Markup, 'Undefined': Undefined})
-
-
-class ASTTransformer(object):
-    """General purpose base class for AST transformations.
-    
-    Every visitor method can be overridden to return an AST node that has been
-    altered or replaced in some way.
-    """
-    _visitors = {}
-
-    def visit(self, node):
-        if node is None:
-            return None
-        v = self._visitors.get(node.__class__)
-        if not v:
-            v = getattr(self.__class__, 'visit%s' % node.__class__.__name__,
-                        self.__class__._visitDefault)
-            self._visitors[node.__class__] = v
-        return v(self, node)
-
-    def _visitDefault(self, node):
-        return node
-
-    def visitExpression(self, node):
-        node.node = self.visit(node.node)
-        return node
-
-    def visitModule(self, node):
-        node.node = self.visit(node.node)
-        return node
-
-    def visitStmt(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        return node
-
-    # Classes, Functions & Accessors
-
-    def visitCallFunc(self, node):
-        node.node = self.visit(node.node)
-        node.args = [self.visit(x) for x in node.args]
-        if node.star_args:
-            node.star_args = self.visit(node.star_args)
-        if node.dstar_args:
-            node.dstar_args = self.visit(node.dstar_args)
-        return node
-
-    def visitClass(self, node):
-        node.bases = [self.visit(x) for x in node.bases]
-        node.code = self.visit(node.code)
-        node.filename = '<string>' # workaround for bug in pycodegen
-        return node
-
-    def visitFunction(self, node):
-        if hasattr(node, 'decorators'):
-            node.decorators = self.visit(node.decorators)
-        node.defaults = [self.visit(x) for x in node.defaults]
-        node.code = self.visit(node.code)
-        node.filename = '<string>' # workaround for bug in pycodegen
-        return node
-
-    def visitGetattr(self, node):
-        node.expr = self.visit(node.expr)
-        return node
-
-    def visitLambda(self, node):
-        node.code = self.visit(node.code)
-        node.filename = '<string>' # workaround for bug in pycodegen
-        return node
-
-    def visitSubscript(self, node):
-        node.expr = self.visit(node.expr)
-        node.subs = [self.visit(x) for x in node.subs]
-        return node
-
-    # Statements
-
-    def visitAssert(self, node):
-        node.test = self.visit(node.test)
-        node.fail = self.visit(node.fail)
-        return node
-
-    def visitAssign(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        node.expr = self.visit(node.expr)
-        return node
-
-    def visitDecorators(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        return node
-
-    def visitFor(self, node):
-        node.assign = self.visit(node.assign)
-        node.list = self.visit(node.list)
-        node.body = self.visit(node.body)
-        node.else_ = self.visit(node.else_)
-        return node
-
-    def visitIf(self, node):
-        node.tests = [self.visit(x) for x in node.tests]
-        node.else_ = self.visit(node.else_)
-        return node
-
-    def _visitPrint(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        node.dest = self.visit(node.dest)
-        return node
-    visitPrint = visitPrintnl = _visitPrint
-
-    def visitRaise(self, node):
-        node.expr1 = self.visit(node.expr1)
-        node.expr2 = self.visit(node.expr2)
-        node.expr3 = self.visit(node.expr3)
-        return node
-
-    def visitTryExcept(self, node):
-        node.body = self.visit(node.body)
-        node.handlers = self.visit(node.handlers)
-        node.else_ = self.visit(node.else_)
-        return node
-
-    def visitTryFinally(self, node):
-        node.body = self.visit(node.body)
-        node.final = self.visit(node.final)
-        return node
-
-    def visitWhile(self, node):
-        node.test = self.visit(node.test)
-        node.body = self.visit(node.body)
-        node.else_ = self.visit(node.else_)
-        return node
-
-    def visitWith(self, node):
-        node.expr = self.visit(node.expr)
-        node.vars = [self.visit(x) for x in node.vars]
-        node.body = self.visit(node.body)
-        return node
-
-    def visitYield(self, node):
-        node.value = self.visit(node.value)
-        return node
-
-    # Operators
-
-    def _visitBoolOp(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        return node
-    visitAnd = visitOr = visitBitand = visitBitor = visitBitxor = _visitBoolOp
-    visitAssTuple = _visitBoolOp
-
-    def _visitBinOp(self, node):
-        node.left = self.visit(node.left)
-        node.right = self.visit(node.right)
-        return node
-    visitAdd = visitSub = _visitBinOp
-    visitDiv = visitFloorDiv = visitMod = visitMul = visitPower = _visitBinOp
-    visitLeftShift = visitRightShift = _visitBinOp
-
-    def visitCompare(self, node):
-        node.expr = self.visit(node.expr)
-        node.ops = [(op, self.visit(n)) for op, n in  node.ops]
-        return node
-
-    def _visitUnaryOp(self, node):
-        node.expr = self.visit(node.expr)
-        return node
-    visitUnaryAdd = visitUnarySub = visitNot = visitInvert = _visitUnaryOp
-    visitBackquote = visitDiscard = _visitUnaryOp
-
-    def visitIfExp(self, node):
-        node.test = self.visit(node.test)
-        node.then = self.visit(node.then)
-        node.else_ = self.visit(node.else_)
-        return node
-
-    # Identifiers, Literals and Comprehensions
-
-    def visitDict(self, node):
-        node.items = [(self.visit(k),
-                       self.visit(v)) for k, v in node.items]
-        return node
-
-    def visitGenExpr(self, node):
-        node.code = self.visit(node.code)
-        node.filename = '<string>' # workaround for bug in pycodegen
-        return node
-
-    def visitGenExprFor(self, node):
-        node.assign = self.visit(node.assign)
-        node.iter = self.visit(node.iter)
-        node.ifs = [self.visit(x) for x in node.ifs]
-        return node
-
-    def visitGenExprIf(self, node):
-        node.test = self.visit(node.test)
-        return node
-
-    def visitGenExprInner(self, node):
-        node.quals = [self.visit(x) for x in node.quals]
-        node.expr = self.visit(node.expr)
-        return node
-
-    def visitKeyword(self, node):
-        node.expr = self.visit(node.expr)
-        return node
-
-    def visitList(self, node):
-        node.nodes = [self.visit(n) for n in node.nodes]
-        return node
-
-    def visitListComp(self, node):
-        node.quals = [self.visit(x) for x in node.quals]
-        node.expr = self.visit(node.expr)
-        return node
-
-    def visitListCompFor(self, node):
-        node.assign = self.visit(node.assign)
-        node.list = self.visit(node.list)
-        node.ifs = [self.visit(x) for x in node.ifs]
-        return node
-
-    def visitListCompIf(self, node):
-        node.test = self.visit(node.test)
-        return node
-
-    def visitSlice(self, node):
-        node.expr = self.visit(node.expr)
-        if node.lower is not None:
-            node.lower = self.visit(node.lower)
-        if node.upper is not None:
-            node.upper = self.visit(node.upper)
-        return node
-
-    def visitSliceobj(self, node):
-        node.nodes = [self.visit(x) for x in node.nodes]
-        return node
-
-    def visitTuple(self, node):
-        node.nodes = [self.visit(n) for n in node.nodes]
-        return node
-
-
-class TemplateASTTransformer(ASTTransformer):
-    """Concrete AST transformer that implements the AST transformations needed
-    for code embedded in templates.
-    """
-
-    def __init__(self):
-        self.locals = []
-
-    def visitConst(self, node):
-        if isinstance(node.value, str):
-            try: # If the string is ASCII, return a `str` object
-                node.value.decode('ascii')
-            except ValueError: # Otherwise return a `unicode` object
-                return ast.Const(node.value.decode('utf-8'))
-        return node
-
-    def visitAssName(self, node):
-        if self.locals:
-            self.locals[-1].add(node.name)
-        return node
-
-    def visitClass(self, node):
-        self.locals.append(set())
-        node = ASTTransformer.visitClass(self, node)
-        self.locals.pop()
-        return node
-
-    def visitFor(self, node):
-        self.locals.append(set())
-        node = ASTTransformer.visitFor(self, node)
-        self.locals.pop()
-        return node
-
-    def visitFunction(self, node):
-        self.locals.append(set(node.argnames))
-        node = ASTTransformer.visitFunction(self, node)
-        self.locals.pop()
-        return node
-
-    def visitGenExpr(self, node):
-        self.locals.append(set())
-        node = ASTTransformer.visitGenExpr(self, node)
-        self.locals.pop()
-        return node
-
-    def visitGetattr(self, node):
-        return ast.CallFunc(ast.Name('_lookup_attr'), [
-            ast.Name('data'), self.visit(node.expr),
-            ast.Const(node.attrname)
-        ])
-
-    def visitLambda(self, node):
-        self.locals.append(set(flatten(node.argnames)))
-        node = ASTTransformer.visitLambda(self, node)
-        self.locals.pop()
-        return node
-
-    def visitListComp(self, node):
-        self.locals.append(set())
-        node = ASTTransformer.visitListComp(self, node)
-        self.locals.pop()
-        return node
-
-    def visitName(self, node):
-        # If the name refers to a local inside a lambda, list comprehension, or
-        # generator expression, leave it alone
-        for frame in self.locals:
-            if node.name in frame:
-                return node
-        # Otherwise, translate the name ref into a context lookup
-        func_args = [ast.Name('data'), ast.Const(node.name)]
-        return ast.CallFunc(ast.Name('_lookup_name'), func_args)
-
-    def visitSubscript(self, node):
-        return ast.CallFunc(ast.Name('_lookup_item'), [
-            ast.Name('data'), self.visit(node.expr),
-            ast.Tuple([self.visit(sub) for sub in node.subs])
-        ])
diff --git a/generator/genshi/template/interpolation.py b/generator/genshi/template/interpolation.py
deleted file mode 100644
index c7c8514..0000000
--- a/generator/genshi/template/interpolation.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""String interpolation routines, i.e. the splitting up a given text into some
-parts that are literal strings, and others that are Python expressions.
-"""
-
-from itertools import chain
-import os
-from tokenize import tokenprog
-
-from genshi.core import TEXT
-from genshi.template.base import TemplateSyntaxError, EXPR
-from genshi.template.eval import Expression
-
-__all__ = ['interpolate']
-__docformat__ = 'restructuredtext en'
-
-NAMESTART = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_'
-NAMECHARS = NAMESTART + '.0123456789'
-PREFIX = '$'
-
-def interpolate(text, basedir=None, filename=None, lineno=-1, offset=0,
-                lookup='lenient'):
-    """Parse the given string and extract expressions.
-    
-    This function is a generator that yields `TEXT` events for literal strings,
-    and `EXPR` events for expressions, depending on the results of parsing the
-    string.
-    
-    >>> for kind, data, pos in interpolate("hey ${foo}bar"):
-    ...     print kind, `data`
-    TEXT u'hey '
-    EXPR Expression('foo')
-    TEXT u'bar'
-    
-    :param text: the text to parse
-    :param basedir: base directory of the file in which the text was found
-                    (optional)
-    :param filename: basename of the file in which the text was found (optional)
-    :param lineno: the line number at which the text was found (optional)
-    :param offset: the column number at which the text starts in the source
-                   (optional)
-    :param lookup: the variable lookup mechanism; either "lenient" (the
-                   default), "strict", or a custom lookup class
-    :return: a list of `TEXT` and `EXPR` events
-    :raise TemplateSyntaxError: when a syntax error in an expression is
-                                encountered
-    """
-    filepath = filename
-    if filepath and basedir:
-        filepath = os.path.join(basedir, filepath)
-    pos = [filepath, lineno, offset]
-
-    textbuf = []
-    textpos = None
-    for is_expr, chunk in chain(lex(text, pos, filepath), [(True, '')]):
-        if is_expr:
-            if textbuf:
-                yield TEXT, u''.join(textbuf), textpos
-                del textbuf[:]
-                textpos = None
-            if chunk:
-                try:
-                    expr = Expression(chunk.strip(), pos[0], pos[1],
-                                     lookup=lookup)
-                    yield EXPR, expr, tuple(pos)
-                except SyntaxError, err:
-                    raise TemplateSyntaxError(err, filepath, pos[1],
-                                              pos[2] + (err.offset or 0))
-        else:
-            textbuf.append(chunk)
-            if textpos is None:
-                textpos = tuple(pos)
-
-        if '\n' in chunk:
-            lines = chunk.splitlines()
-            pos[1] += len(lines) - 1
-            pos[2] += len(lines[-1])
-        else:
-            pos[2] += len(chunk)
-
-def lex(text, textpos, filepath):
-    offset = pos = 0
-    end = len(text)
-    escaped = False
-
-    while 1:
-        if escaped:
-            offset = text.find(PREFIX, offset + 2)
-            escaped = False
-        else:
-            offset = text.find(PREFIX, pos)
-        if offset < 0 or offset == end - 1:
-            break
-        next = text[offset + 1]
-
-        if next == '{':
-            if offset > pos:
-                yield False, text[pos:offset]
-            pos = offset + 2
-            level = 1
-            while level:
-                match = tokenprog.match(text, pos)
-                if match is None:
-                    raise TemplateSyntaxError('invalid syntax',  filepath,
-                                              *textpos[1:])
-                pos = match.end()
-                tstart, tend = match.regs[3]
-                token = text[tstart:tend]
-                if token == '{':
-                    level += 1
-                elif token == '}':
-                    level -= 1
-            yield True, text[offset + 2:pos - 1]
-
-        elif next in NAMESTART:
-            if offset > pos:
-                yield False, text[pos:offset]
-                pos = offset
-            pos += 1
-            while pos < end:
-                char = text[pos]
-                if char not in NAMECHARS:
-                    break
-                pos += 1
-            yield True, text[offset + 1:pos].strip()
-
-        elif not escaped and next == PREFIX:
-            escaped = True
-            pos = offset + 1
-
-        else:
-            yield False, text[pos:offset + 1]
-            pos = offset + 1
-
-    if pos < end:
-        yield False, text[pos:]
diff --git a/generator/genshi/template/loader.py b/generator/genshi/template/loader.py
deleted file mode 100644
index 23d5de2..0000000
--- a/generator/genshi/template/loader.py
+++ /dev/null
@@ -1,217 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Template loading and caching."""
-
-import os
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-
-from genshi.template.base import TemplateError
-from genshi.util import LRUCache
-
-__all__ = ['TemplateLoader', 'TemplateNotFound']
-__docformat__ = 'restructuredtext en'
-
-
-class TemplateNotFound(TemplateError):
-    """Exception raised when a specific template file could not be found."""
-
-    def __init__(self, name, search_path):
-        """Create the exception.
-        
-        :param name: the filename of the template
-        :param search_path: the search path used to lookup the template
-        """
-        TemplateError.__init__(self, 'Template "%s" not found' % name)
-        self.search_path = search_path
-
-
-class TemplateLoader(object):
-    """Responsible for loading templates from files on the specified search
-    path.
-    
-    >>> import tempfile
-    >>> fd, path = tempfile.mkstemp(suffix='.html', prefix='template')
-    >>> os.write(fd, '<p>$var</p>')
-    11
-    >>> os.close(fd)
-    
-    The template loader accepts a list of directory paths that are then used
-    when searching for template files, in the given order:
-    
-    >>> loader = TemplateLoader([os.path.dirname(path)])
-    
-    The `load()` method first checks the template cache whether the requested
-    template has already been loaded. If not, it attempts to locate the
-    template file, and returns the corresponding `Template` object:
-    
-    >>> from genshi.template import MarkupTemplate
-    >>> template = loader.load(os.path.basename(path))
-    >>> isinstance(template, MarkupTemplate)
-    True
-    
-    Template instances are cached: requesting a template with the same name
-    results in the same instance being returned:
-    
-    >>> loader.load(os.path.basename(path)) is template
-    True
-    
-    >>> os.remove(path)
-    """
-    def __init__(self, search_path=None, auto_reload=False,
-                 default_encoding=None, max_cache_size=25, default_class=None,
-                 variable_lookup='lenient', callback=None):
-        """Create the template laoder.
-        
-        :param search_path: a list of absolute path names that should be
-                            searched for template files, or a string containing
-                            a single absolute path
-        :param auto_reload: whether to check the last modification time of
-                            template files, and reload them if they have changed
-        :param default_encoding: the default encoding to assume when loading
-                                 templates; defaults to UTF-8
-        :param max_cache_size: the maximum number of templates to keep in the
-                               cache
-        :param default_class: the default `Template` subclass to use when
-                              instantiating templates
-        :param variable_lookup: the variable lookup mechanism; either "lenient"
-                                (the default), "strict", or a custom lookup
-                                class
-        :param callback: (optional) a callback function that is invoked after a
-                         template was initialized by this loader; the function
-                         is passed the template object as only argument. This
-                         callback can be used for example to add any desired
-                         filters to the template
-        :see: `LenientLookup`, `StrictLookup`
-        """
-        from genshi.template.markup import MarkupTemplate
-
-        self.search_path = search_path
-        if self.search_path is None:
-            self.search_path = []
-        elif isinstance(self.search_path, basestring):
-            self.search_path = [self.search_path]
-        self.auto_reload = auto_reload
-        self.default_encoding = default_encoding
-        self.default_class = default_class or MarkupTemplate
-        self.variable_lookup = variable_lookup
-        if callback is not None and not callable(callback):
-            raise TypeError('The "callback" parameter needs to be callable')
-        self.callback = callback
-        self._cache = LRUCache(max_cache_size)
-        self._mtime = {}
-        self._lock = threading.Lock()
-
-    def load(self, filename, relative_to=None, cls=None, encoding=None):
-        """Load the template with the given name.
-        
-        If the `filename` parameter is relative, this method searches the search
-        path trying to locate a template matching the given name. If the file
-        name is an absolute path, the search path is ignored.
-        
-        If the requested template is not found, a `TemplateNotFound` exception
-        is raised. Otherwise, a `Template` object is returned that represents
-        the parsed template.
-        
-        Template instances are cached to avoid having to parse the same
-        template file more than once. Thus, subsequent calls of this method
-        with the same template file name will return the same `Template`
-        object (unless the ``auto_reload`` option is enabled and the file was
-        changed since the last parse.)
-        
-        If the `relative_to` parameter is provided, the `filename` is
-        interpreted as being relative to that path.
-        
-        :param filename: the relative path of the template file to load
-        :param relative_to: the filename of the template from which the new
-                            template is being loaded, or ``None`` if the
-                            template is being loaded directly
-        :param cls: the class of the template object to instantiate
-        :param encoding: the encoding of the template to load; defaults to the
-                         ``default_encoding`` of the loader instance
-        :return: the loaded `Template` instance
-        :raises TemplateNotFound: if a template with the given name could not be
-                                  found
-        """
-        if cls is None:
-            cls = self.default_class
-        if encoding is None:
-            encoding = self.default_encoding
-        if relative_to and not os.path.isabs(relative_to):
-            filename = os.path.join(os.path.dirname(relative_to), filename)
-        filename = os.path.normpath(filename)
-
-        self._lock.acquire()
-        try:
-            # First check the cache to avoid reparsing the same file
-            try:
-                tmpl = self._cache[filename]
-                if not self.auto_reload or \
-                        os.path.getmtime(tmpl.filepath) == self._mtime[filename]:
-                    return tmpl
-            except KeyError:
-                pass
-
-            search_path = self.search_path
-            isabs = False
-
-            if os.path.isabs(filename):
-                # Bypass the search path if the requested filename is absolute
-                search_path = [os.path.dirname(filename)]
-                isabs = True
-
-            elif relative_to and os.path.isabs(relative_to):
-                # Make sure that the directory containing the including
-                # template is on the search path
-                dirname = os.path.dirname(relative_to)
-                if dirname not in search_path:
-                    search_path = search_path + [dirname]
-                isabs = True
-
-            elif not search_path:
-                # Uh oh, don't know where to look for the template
-                raise TemplateError('Search path for templates not configured')
-
-            for dirname in search_path:
-                filepath = os.path.join(dirname, filename)
-                try:
-                    fileobj = open(filepath, 'U')
-                    try:
-                        if isabs:
-                            # If the filename of either the included or the 
-                            # including template is absolute, make sure the
-                            # included template gets an absolute path, too,
-                            # so that nested include work properly without a
-                            # search path
-                            filename = os.path.join(dirname, filename)
-                            dirname = ''
-                        tmpl = cls(fileobj, basedir=dirname, filename=filename,
-                                   loader=self, lookup=self.variable_lookup,
-                                   encoding=encoding)
-                        if self.callback:
-                            self.callback(tmpl)
-                        self._cache[filename] = tmpl
-                        self._mtime[filename] = os.path.getmtime(filepath)
-                    finally:
-                        fileobj.close()
-                    return tmpl
-                except IOError:
-                    continue
-
-            raise TemplateNotFound(filename, search_path)
-
-        finally:
-            self._lock.release()
diff --git a/generator/genshi/template/markup.py b/generator/genshi/template/markup.py
deleted file mode 100644
index 5df367c..0000000
--- a/generator/genshi/template/markup.py
+++ /dev/null
@@ -1,344 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Markup templating engine."""
-
-from itertools import chain
-import sys
-from textwrap import dedent
-
-from genshi.core import Attrs, Namespace, Stream, StreamEventKind
-from genshi.core import START, END, START_NS, END_NS, TEXT, PI, COMMENT
-from genshi.input import XMLParser
-from genshi.template.base import BadDirectiveError, Template, \
-                                 TemplateSyntaxError, _apply_directives, SUB
-from genshi.template.eval import Suite
-from genshi.template.interpolation import interpolate
-from genshi.template.loader import TemplateNotFound
-from genshi.template.directives import *
-
-if sys.version_info < (2, 4):
-    _ctxt2dict = lambda ctxt: ctxt.frames[0]
-else:
-    _ctxt2dict = lambda ctxt: ctxt
-
-__all__ = ['MarkupTemplate']
-__docformat__ = 'restructuredtext en'
-
-
-class MarkupTemplate(Template):
-    """Implementation of the template language for XML-based templates.
-    
-    >>> tmpl = MarkupTemplate('''<ul xmlns:py="http://genshi.edgewall.org/">
-    ...   <li py:for="item in items">${item}</li>
-    ... </ul>''')
-    >>> print tmpl.generate(items=[1, 2, 3])
-    <ul>
-      <li>1</li><li>2</li><li>3</li>
-    </ul>
-    """
-    EXEC = StreamEventKind('EXEC')
-    """Stream event kind representing a Python code suite to execute."""
-
-    INCLUDE = StreamEventKind('INCLUDE')
-    """Stream event kind representing the inclusion of another template."""
-
-    DIRECTIVE_NAMESPACE = Namespace('http://genshi.edgewall.org/')
-    XINCLUDE_NAMESPACE = Namespace('http://www.w3.org/2001/XInclude')
-
-    directives = [('def', DefDirective),
-                  ('match', MatchDirective),
-                  ('when', WhenDirective),
-                  ('otherwise', OtherwiseDirective),
-                  ('for', ForDirective),
-                  ('if', IfDirective),
-                  ('choose', ChooseDirective),
-                  ('with', WithDirective),
-                  ('replace', ReplaceDirective),
-                  ('content', ContentDirective),
-                  ('attrs', AttrsDirective),
-                  ('strip', StripDirective)]
-
-    def __init__(self, source, basedir=None, filename=None, loader=None,
-                 encoding=None, lookup='lenient'):
-        Template.__init__(self, source, basedir=basedir, filename=filename,
-                          loader=loader, encoding=encoding, lookup=lookup)
-
-        self.filters += [self._exec, self._match]
-        if loader:
-            self.filters.append(self._include)
-
-    def _parse(self, source, encoding):
-        streams = [[]] # stacked lists of events of the "compiled" template
-        dirmap = {} # temporary mapping of directives to elements
-        ns_prefix = {}
-        depth = 0
-        in_fallback = 0
-        include_href = None
-
-        if not isinstance(source, Stream):
-            source = XMLParser(source, filename=self.filename,
-                               encoding=encoding)
-
-        for kind, data, pos in source:
-            stream = streams[-1]
-
-            if kind is START_NS:
-                # Strip out the namespace declaration for template directives
-                prefix, uri = data
-                ns_prefix[prefix] = uri
-                if uri not in (self.DIRECTIVE_NAMESPACE,
-                               self.XINCLUDE_NAMESPACE):
-                    stream.append((kind, data, pos))
-
-            elif kind is END_NS:
-                uri = ns_prefix.pop(data, None)
-                if uri and uri not in (self.DIRECTIVE_NAMESPACE,
-                                       self.XINCLUDE_NAMESPACE):
-                    stream.append((kind, data, pos))
-
-            elif kind is START:
-                # Record any directive attributes in start tags
-                tag, attrs = data
-                directives = []
-                strip = False
-
-                if tag in self.DIRECTIVE_NAMESPACE:
-                    cls = self._dir_by_name.get(tag.localname)
-                    if cls is None:
-                        raise BadDirectiveError(tag.localname, self.filepath,
-                                                pos[1])
-                    value = attrs.get(getattr(cls, 'ATTRIBUTE', None), '')
-                    directives.append((cls, value, ns_prefix.copy(), pos))
-                    strip = True
-
-                new_attrs = []
-                for name, value in attrs:
-                    if name in self.DIRECTIVE_NAMESPACE:
-                        cls = self._dir_by_name.get(name.localname)
-                        if cls is None:
-                            raise BadDirectiveError(name.localname,
-                                                    self.filepath, pos[1])
-                        directives.append((cls, value, ns_prefix.copy(), pos))
-                    else:
-                        if value:
-                            value = list(interpolate(value, self.basedir,
-                                                     pos[0], pos[1], pos[2],
-                                                     lookup=self.lookup))
-                            if len(value) == 1 and value[0][0] is TEXT:
-                                value = value[0][1]
-                        else:
-                            value = [(TEXT, u'', pos)]
-                        new_attrs.append((name, value))
-                new_attrs = Attrs(new_attrs)
-
-                if directives:
-                    index = self._dir_order.index
-                    directives.sort(lambda a, b: cmp(index(a[0]), index(b[0])))
-                    dirmap[(depth, tag)] = (directives, len(stream), strip)
-
-                if tag in self.XINCLUDE_NAMESPACE:
-                    if tag.localname == 'include':
-                        include_href = new_attrs.get('href')
-                        if not include_href:
-                            raise TemplateSyntaxError('Include misses required '
-                                                      'attribute "href"',
-                                                      self.filepath, *pos[1:])
-                        streams.append([])
-                    elif tag.localname == 'fallback':
-                        in_fallback += 1
-
-                else:
-                    stream.append((kind, (tag, new_attrs), pos))
-
-                depth += 1
-
-            elif kind is END:
-                depth -= 1
-
-                if in_fallback and data == self.XINCLUDE_NAMESPACE['fallback']:
-                    in_fallback -= 1
-                elif data == self.XINCLUDE_NAMESPACE['include']:
-                    fallback = streams.pop()
-                    stream = streams[-1]
-                    stream.append((INCLUDE, (include_href, fallback), pos))
-                else:
-                    stream.append((kind, data, pos))
-
-                # If there have have directive attributes with the corresponding
-                # start tag, move the events inbetween into a "subprogram"
-                if (depth, data) in dirmap:
-                    directives, start_offset, strip = dirmap.pop((depth, data))
-                    substream = stream[start_offset:]
-                    if strip:
-                        substream = substream[1:-1]
-                    stream[start_offset:] = [(SUB, (directives, substream),
-                                              pos)]
-
-            elif kind is PI and data[0] == 'python':
-                try:
-                    # As Expat doesn't report whitespace between the PI target
-                    # and the data, we have to jump through some hoops here to
-                    # get correctly indented Python code
-                    # Unfortunately, we'll still probably not get the line
-                    # number quite right
-                    lines = [line.expandtabs() for line in data[1].splitlines()]
-                    first = lines[0]
-                    rest = dedent('\n'.join(lines[1:]))
-                    if first.rstrip().endswith(':') and not rest[0].isspace():
-                        rest = '\n'.join(['    ' + line for line
-                                          in rest.splitlines()])
-                    source = '\n'.join([first, rest])
-                    suite = Suite(source, self.filepath, pos[1],
-                                  lookup=self.lookup)
-                except SyntaxError, err:
-                    raise TemplateSyntaxError(err, self.filepath,
-                                              pos[1] + (err.lineno or 1) - 1,
-                                              pos[2] + (err.offset or 0))
-                stream.append((EXEC, suite, pos))
-
-            elif kind is TEXT:
-                for kind, data, pos in interpolate(data, self.basedir, pos[0],
-                                                   pos[1], pos[2],
-                                                   lookup=self.lookup):
-                    stream.append((kind, data, pos))
-
-            elif kind is COMMENT:
-                if not data.lstrip().startswith('!'):
-                    stream.append((kind, data, pos))
-
-            else:
-                stream.append((kind, data, pos))
-
-        assert len(streams) == 1
-        return streams[0]
-
-    def _prepare(self, stream):
-        for kind, data, pos in Template._prepare(self, stream):
-            if kind is INCLUDE:
-                data = data[0], list(self._prepare(data[1]))
-            yield kind, data, pos
-
-    def _exec(self, stream, ctxt):
-        """Internal stream filter that executes code in ``<?python ?>``
-        processing instructions.
-        """
-        for event in stream:
-            if event[0] is EXEC:
-                event[1].execute(_ctxt2dict(ctxt))
-            else:
-                yield event
-
-    def _include(self, stream, ctxt):
-        """Internal stream filter that performs inclusion of external
-        template files.
-        """
-        for event in stream:
-            if event[0] is INCLUDE:
-                href, fallback = event[1]
-                if not isinstance(href, basestring):
-                    parts = []
-                    for subkind, subdata, subpos in self._eval(href, ctxt):
-                        if subkind is TEXT:
-                            parts.append(subdata)
-                    href = u''.join([x for x in parts if x is not None])
-                try:
-                    tmpl = self.loader.load(href, relative_to=event[2][0])
-                    for event in tmpl.generate(ctxt):
-                        yield event
-                except TemplateNotFound:
-                    if fallback is None:
-                        raise
-                    for filter_ in self.filters:
-                        fallback = filter_(iter(fallback), ctxt)
-                    for event in fallback:
-                        yield event
-            else:
-                yield event
-
-    def _match(self, stream, ctxt, match_templates=None):
-        """Internal stream filter that applies any defined match templates
-        to the stream.
-        """
-        if match_templates is None:
-            match_templates = ctxt._match_templates
-
-        tail = []
-        def _strip(stream):
-            depth = 1
-            while 1:
-                event = stream.next()
-                if event[0] is START:
-                    depth += 1
-                elif event[0] is END:
-                    depth -= 1
-                if depth > 0:
-                    yield event
-                else:
-                    tail[:] = [event]
-                    break
-
-        for event in stream:
-
-            # We (currently) only care about start and end events for matching
-            # We might care about namespace events in the future, though
-            if not match_templates or (event[0] is not START and
-                                       event[0] is not END):
-                yield event
-                continue
-
-            for idx, (test, path, template, namespaces, directives) in \
-                    enumerate(match_templates):
-
-                if test(event, namespaces, ctxt) is True:
-
-                    # Let the remaining match templates know about the event so
-                    # they get a chance to update their internal state
-                    for test in [mt[0] for mt in match_templates[idx + 1:]]:
-                        test(event, namespaces, ctxt, updateonly=True)
-
-                    # Consume and store all events until an end event
-                    # corresponding to this start event is encountered
-                    content = chain([event],
-                                    self._match(_strip(stream), ctxt,
-                                                [match_templates[idx]]),
-                                    tail)
-                    content = list(self._include(content, ctxt))
-
-                    for test in [mt[0] for mt in match_templates]:
-                        test(tail[0], namespaces, ctxt, updateonly=True)
-
-                    # Make the select() function available in the body of the
-                    # match template
-                    def select(path):
-                        return Stream(content).select(path, namespaces, ctxt)
-                    ctxt.push(dict(select=select))
-
-                    # Recursively process the output
-                    template = _apply_directives(template, ctxt, directives)
-                    for event in self._match(self._eval(self._flatten(template,
-                                                                      ctxt),
-                                                        ctxt), ctxt,
-                                             match_templates[:idx] +
-                                             match_templates[idx + 1:]):
-                        yield event
-
-                    ctxt.pop()
-                    break
-
-            else: # no matches
-                yield event
-
-
-EXEC = MarkupTemplate.EXEC
-INCLUDE = MarkupTemplate.INCLUDE
diff --git a/generator/genshi/template/plugin.py b/generator/genshi/template/plugin.py
deleted file mode 100644
index 9950417..0000000
--- a/generator/genshi/template/plugin.py
+++ /dev/null
@@ -1,154 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# Copyright (C) 2006 Matthew Good
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Basic support for the template engine plugin API used by TurboGears and
-CherryPy/Buffet.
-"""
-
-from pkg_resources import resource_filename
-
-from genshi.input import ET, HTML, XML
-from genshi.output import DocType
-from genshi.template.base import Template
-from genshi.template.loader import TemplateLoader
-from genshi.template.markup import MarkupTemplate
-from genshi.template.text import TextTemplate
-
-__all__ = ['ConfigurationError', 'AbstractTemplateEnginePlugin',
-           'MarkupTemplateEnginePlugin', 'TextTemplateEnginePlugin']
-__docformat__ = 'restructuredtext en'
-
-
-class ConfigurationError(Exception):
-    """Exception raised when invalid plugin options are encountered."""
-
-
-class AbstractTemplateEnginePlugin(object):
-    """Implementation of the plugin API."""
-
-    template_class = None
-    extension = None
-
-    def __init__(self, extra_vars_func=None, options=None):
-        self.get_extra_vars = extra_vars_func
-        if options is None:
-            options = {}
-        self.options = options
-
-        self.default_encoding = options.get('genshi.default_encoding', 'utf-8')
-        auto_reload = options.get('genshi.auto_reload', '1')
-        if isinstance(auto_reload, basestring):
-            auto_reload = auto_reload.lower() in ('1', 'on', 'yes', 'true')
-        search_path = filter(None, options.get('genshi.search_path', '').split(':'))
-        self.use_package_naming = not search_path
-        try:
-            max_cache_size = int(options.get('genshi.max_cache_size', 25))
-        except ValueError:
-            raise ConfigurationError('Invalid value for max_cache_size: "%s"' %
-                                     options.get('genshi.max_cache_size'))
-
-        lookup_errors = options.get('genshi.lookup_errors', 'lenient')
-        if lookup_errors not in ('lenient', 'strict'):
-            raise ConfigurationError('Unknown lookup errors mode "%s"' %
-                                     lookup_errors)
-
-        self.loader = TemplateLoader(filter(None, search_path),
-                                     auto_reload=auto_reload,
-                                     max_cache_size=max_cache_size,
-                                     default_class=self.template_class,
-                                     variable_lookup=lookup_errors)
-
-    def load_template(self, templatename, template_string=None):
-        """Find a template specified in python 'dot' notation, or load one from
-        a string.
-        """
-        if template_string is not None:
-            return self.template_class(template_string)
-
-        if self.use_package_naming:
-            divider = templatename.rfind('.')
-            if divider >= 0:
-                package = templatename[:divider]
-                basename = templatename[divider + 1:] + self.extension
-                templatename = resource_filename(package, basename)
-
-        return self.loader.load(templatename)
-
-    def _get_render_options(self, format=None):
-        if format is None:
-            format = self.default_format
-        kwargs = {'method': format}
-        if self.default_encoding:
-            kwargs['encoding'] = self.default_encoding
-        return kwargs
-
-    def render(self, info, format=None, fragment=False, template=None):
-        """Render the template to a string using the provided info."""
-        kwargs = self._get_render_options(format=format)
-        return self.transform(info, template).render(**kwargs)
-
-    def transform(self, info, template):
-        """Render the output to an event stream."""
-        if not isinstance(template, Template):
-            template = self.load_template(template)
-        return template.generate(**info)
-
-
-class MarkupTemplateEnginePlugin(AbstractTemplateEnginePlugin):
-    """Implementation of the plugin API for markup templates."""
-
-    template_class = MarkupTemplate
-    extension = '.html'
-
-    doctypes = {'html': DocType.HTML, 'html-strict': DocType.HTML_STRICT,
-                'html-transitional': DocType.HTML_TRANSITIONAL,
-                'html5': DocType.HTML5,
-                'xhtml': DocType.XHTML, 'xhtml-strict': DocType.XHTML_STRICT,
-                'xhtml-transitional': DocType.XHTML_TRANSITIONAL}
-
-    def __init__(self, extra_vars_func=None, options=None):
-        AbstractTemplateEnginePlugin.__init__(self, extra_vars_func, options)
-
-        doctype = self.options.get('genshi.default_doctype')
-        if doctype and doctype not in self.doctypes:
-            raise ConfigurationError('Unknown doctype "%s"' % doctype)
-        self.default_doctype = self.doctypes.get(doctype)
-
-        format = self.options.get('genshi.default_format', 'html')
-        if format not in ('html', 'xhtml', 'xml', 'text'):
-            raise ConfigurationError('Unknown output format "%s"' % format)
-        self.default_format = format
-
-    def _get_render_options(self, format=None):
-        kwargs = super(MarkupTemplateEnginePlugin,
-                       self)._get_render_options(format)
-        if self.default_doctype:
-            kwargs['doctype'] = self.default_doctype
-        return kwargs
-
-    def transform(self, info, template):
-        """Render the output to an event stream."""
-        data = {'ET': ET, 'HTML': HTML, 'XML': XML}
-        if self.get_extra_vars:
-            data.update(self.get_extra_vars())
-        data.update(info)
-        return super(MarkupTemplateEnginePlugin, self).transform(data, template)
-
-
-class TextTemplateEnginePlugin(AbstractTemplateEnginePlugin):
-    """Implementation of the plugin API for text templates."""
-
-    template_class = TextTemplate
-    extension = '.txt'
-    default_format = 'text'
diff --git a/generator/genshi/template/text.py b/generator/genshi/template/text.py
deleted file mode 100644
index 1f7327a..0000000
--- a/generator/genshi/template/text.py
+++ /dev/null
@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Plain text templating engine."""
-
-import re
-
-from genshi.template.base import BadDirectiveError, Template, SUB
-from genshi.template.directives import *
-from genshi.template.interpolation import interpolate
-
-__all__ = ['TextTemplate']
-__docformat__ = 'restructuredtext en'
-
-
-class TextTemplate(Template):
-    """Implementation of a simple text-based template engine.
-    
-    >>> tmpl = TextTemplate('''Dear $name,
-    ... 
-    ... We have the following items for you:
-    ... #for item in items
-    ...  * $item
-    ... #end
-    ... 
-    ... All the best,
-    ... Foobar''')
-    >>> print tmpl.generate(name='Joe', items=[1, 2, 3]).render('text')
-    Dear Joe,
-    <BLANKLINE>
-    We have the following items for you:
-     * 1
-     * 2
-     * 3
-    <BLANKLINE>
-    All the best,
-    Foobar
-    """
-    directives = [('def', DefDirective),
-                  ('when', WhenDirective),
-                  ('otherwise', OtherwiseDirective),
-                  ('for', ForDirective),
-                  ('if', IfDirective),
-                  ('choose', ChooseDirective),
-                  ('with', WithDirective)]
-
-    _DIRECTIVE_RE = re.compile(r'(?:^[ \t]*(?<!\\)#(end).*\n?)|'
-                               r'(?:^[ \t]*(?<!\\)#((?:\w+|#).*)\n?)',
-                               re.MULTILINE)
-
-    def _parse(self, source, encoding):
-        """Parse the template from text input."""
-        stream = [] # list of events of the "compiled" template
-        dirmap = {} # temporary mapping of directives to elements
-        depth = 0
-        if not encoding:
-            encoding = 'utf-8'
-
-        source = source.read().decode(encoding, 'replace')
-        offset = 0
-        lineno = 1
-
-        for idx, mo in enumerate(self._DIRECTIVE_RE.finditer(source)):
-            start, end = mo.span()
-            if start > offset:
-                text = source[offset:start]
-                for kind, data, pos in interpolate(text, self.basedir,
-                                                   self.filename, lineno,
-                                                   lookup=self.lookup):
-                    stream.append((kind, data, pos))
-                lineno += len(text.splitlines())
-
-            text = source[start:end].lstrip()[1:]
-            lineno += len(text.splitlines())
-            directive = text.split(None, 1)
-            if len(directive) > 1:
-                command, value = directive
-            else:
-                command, value = directive[0], None
-
-            if command == 'end':
-                depth -= 1
-                if depth in dirmap:
-                    directive, start_offset = dirmap.pop(depth)
-                    substream = stream[start_offset:]
-                    stream[start_offset:] = [(SUB, ([directive], substream),
-                                              (self.filepath, lineno, 0))]
-            elif command != '#':
-                cls = self._dir_by_name.get(command)
-                if cls is None:
-                    raise BadDirectiveError(command)
-                directive = cls, value, None, (self.filepath, lineno, 0)
-                dirmap[depth] = (directive, len(stream))
-                depth += 1
-
-            offset = end
-
-        if offset < len(source):
-            text = source[offset:].replace('\\#', '#')
-            for kind, data, pos in interpolate(text, self.basedir,
-                                               self.filename, lineno,
-                                               lookup=self.lookup):
-                stream.append((kind, data, pos))
-
-        return stream
diff --git a/generator/genshi/util.py b/generator/genshi/util.py
deleted file mode 100644
index e50d569..0000000
--- a/generator/genshi/util.py
+++ /dev/null
@@ -1,240 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# Copyright (C) 2006-2007 Edgewall Software
-# All rights reserved.
-#
-# This software is licensed as described in the file COPYING, which
-# you should have received as part of this distribution. The terms
-# are also available at http://genshi.edgewall.org/wiki/License.
-#
-# This software consists of voluntary contributions made by many
-# individuals. For the exact contribution history, see the revision
-# history and logs, available at http://genshi.edgewall.org/log/.
-
-"""Various utility classes and functions."""
-
-import htmlentitydefs
-import re
-
-__docformat__ = 'restructuredtext en'
-
-
-class LRUCache(dict):
-    """A dictionary-like object that stores only a certain number of items, and
-    discards its least recently used item when full.
-    
-    >>> cache = LRUCache(3)
-    >>> cache['A'] = 0
-    >>> cache['B'] = 1
-    >>> cache['C'] = 2
-    >>> len(cache)
-    3
-    
-    >>> cache['A']
-    0
-    
-    Adding new items to the cache does not increase its size. Instead, the least
-    recently used item is dropped:
-    
-    >>> cache['D'] = 3
-    >>> len(cache)
-    3
-    >>> 'B' in cache
-    False
-    
-    Iterating over the cache returns the keys, starting with the most recently
-    used:
-    
-    >>> for key in cache:
-    ...     print key
-    D
-    A
-    C
-
-    This code is based on the LRUCache class from ``myghtyutils.util``, written
-    by Mike Bayer and released under the MIT license. See:
-
-      http://svn.myghty.org/myghtyutils/trunk/lib/myghtyutils/util.py
-    """
-
-    class _Item(object):
-        def __init__(self, key, value):
-            self.previous = self.next = None
-            self.key = key
-            self.value = value
-        def __repr__(self):
-            return repr(self.value)
-
-    def __init__(self, capacity):
-        self._dict = dict()
-        self.capacity = capacity
-        self.head = None
-        self.tail = None
-
-    def __contains__(self, key):
-        return key in self._dict
-
-    def __iter__(self):
-        cur = self.head
-        while cur:
-            yield cur.key
-            cur = cur.next
-
-    def __len__(self):
-        return len(self._dict)
-
-    def __getitem__(self, key):
-        item = self._dict[key]
-        self._update_item(item)
-        return item.value
-
-    def __setitem__(self, key, value):
-        item = self._dict.get(key)
-        if item is None:
-            item = self._Item(key, value)
-            self._dict[key] = item
-            self._insert_item(item)
-        else:
-            item.value = value
-            self._update_item(item)
-            self._manage_size()
-
-    def __repr__(self):
-        return repr(self._dict)
-
-    def _insert_item(self, item):
-        item.previous = None
-        item.next = self.head
-        if self.head is not None:
-            self.head.previous = item
-        else:
-            self.tail = item
-        self.head = item
-        self._manage_size()
-
-    def _manage_size(self):
-        while len(self._dict) > self.capacity:
-            olditem = self._dict[self.tail.key]
-            del self._dict[self.tail.key]
-            if self.tail != self.head:
-                self.tail = self.tail.previous
-                self.tail.next = None
-            else:
-                self.head = self.tail = None
-
-    def _update_item(self, item):
-        if self.head == item:
-            return
-
-        previous = item.previous
-        previous.next = item.next
-        if item.next is not None:
-            item.next.previous = previous
-        else:
-            self.tail = previous
-
-        item.previous = None
-        item.next = self.head
-        self.head.previous = self.head = item
-
-
-def flatten(items):
-    """Flattens a potentially nested sequence into a flat list.
-    
-    :param items: the sequence to flatten
-    
-    >>> flatten((1, 2))
-    [1, 2]
-    >>> flatten([1, (2, 3), 4])
-    [1, 2, 3, 4]
-    >>> flatten([1, (2, [3, 4]), 5])
-    [1, 2, 3, 4, 5]
-    """
-    retval = []
-    for item in items:
-        if isinstance(item, (list, tuple)):
-            retval += flatten(item)
-        else:
-            retval.append(item)
-    return retval
-
-def plaintext(text, keeplinebreaks=True):
-    """Returns the text as a `unicode` string with all entities and tags
-    removed.
-    
-    >>> plaintext('<b>1 &lt; 2</b>')
-    u'1 < 2'
-    
-    The `keeplinebreaks` parameter can be set to ``False`` to replace any line
-    breaks by simple spaces:
-    
-    >>> plaintext('''<b>1
-    ... &lt;
-    ... 2</b>''', keeplinebreaks=False)
-    u'1 < 2'
-    
-    :param text: the text to convert to plain text
-    :param keeplinebreaks: whether line breaks in the text should be kept intact
-    :return: the text with tags and entities removed
-    """
-    text = stripentities(striptags(text))
-    if not keeplinebreaks:
-        text = text.replace(u'\n', u' ')
-    return text
-
-_STRIPENTITIES_RE = re.compile(r'&(?:#((?:\d+)|(?:[xX][0-9a-fA-F]+));?|(\w+);)')
-def stripentities(text, keepxmlentities=False):
-    """Return a copy of the given text with any character or numeric entities
-    replaced by the equivalent UTF-8 characters.
-    
-    >>> stripentities('1 &lt; 2')
-    u'1 < 2'
-    >>> stripentities('more &hellip;')
-    u'more \u2026'
-    >>> stripentities('&#8230;')
-    u'\u2026'
-    >>> stripentities('&#x2026;')
-    u'\u2026'
-    
-    If the `keepxmlentities` parameter is provided and is a truth value, the
-    core XML entities (&amp;, &apos;, &gt;, &lt; and &quot;) are left intact.
-
-    >>> stripentities('1 &lt; 2 &hellip;', keepxmlentities=True)
-    u'1 &lt; 2 \u2026'
-    """
-    def _replace_entity(match):
-        if match.group(1): # numeric entity
-            ref = match.group(1)
-            if ref.startswith('x'):
-                ref = int(ref[1:], 16)
-            else:
-                ref = int(ref, 10)
-            return unichr(ref)
-        else: # character entity
-            ref = match.group(2)
-            if keepxmlentities and ref in ('amp', 'apos', 'gt', 'lt', 'quot'):
-                return u'&%s;' % ref
-            try:
-                return unichr(htmlentitydefs.name2codepoint[ref])
-            except KeyError:
-                if keepxmlentities:
-                    return u'&amp;%s;' % ref
-                else:
-                    return ref
-    return _STRIPENTITIES_RE.sub(_replace_entity, text)
-
-_STRIPTAGS_RE = re.compile(r'<[^>]*?>')
-def striptags(text):
-    """Return a copy of the text with any XML/HTML tags removed.
-    
-    >>> striptags('<span>Foo</span> bar')
-    'Foo bar'
-    >>> striptags('<span class="bar">Foo</span>')
-    'Foo'
-    >>> striptags('Foo<br />')
-    'Foo'
-    
-    :param text: the string to remove tags from
-    :return: the text with tags removed
-    """
-    return _STRIPTAGS_RE.sub('', text)
diff --git a/generator/gitlog.py b/generator/gitlog.py
index 9ad7954..7d4f76a 100644
--- a/generator/gitlog.py
+++ b/generator/gitlog.py
@@ -15,7 +15,7 @@ def get_log_info(file):
     repo_dir = _get_repo_dir(file)
     fmt = '%n'.join(map(lambda p : '='.join(p), _PROPERTIES))
     output = _execute(repo_dir, 'git', 'log', '-1', '--pretty=%s' % fmt, '--name-only', '--', file)
-    lines = output.split('\n')
+    lines = output.decode().split('\n')
     info = {}
     for l in lines:
         if not l:
diff --git a/generator/sitegen.py b/generator/sitegen.py
index 051ab67..d10402c 100644
--- a/generator/sitegen.py
+++ b/generator/sitegen.py
@@ -1,16 +1,15 @@
-"""Simple Generator for EclEmma's site at SourceForge
-
-$LastChangedDate$
-$Revision$
+"""Simple Generator for www.eclemma.org
 """
-import os, os.path, sys, urlparse
+import os, os.path, sys
 import itertools
 import genshi, genshi.input, genshi.template
 import gitlog
 
+from urllib.parse import urljoin
+
 templateloader = genshi.template.TemplateLoader(['./templates'])
         
-PAGE = templateloader.load('page.html')
+PAGE = templateloader.load('page.html', encoding='UTF-8')
 
 def _rellink(base, href):
     base = base.split('/')
@@ -38,7 +37,7 @@ def __call__(self, stream):
                 attrs = data[1]
                 for ref in filter(lambda v: v, map(lambda n: attrs.get(n), self.ATTRIBUTES)):
                     if not filter(lambda p: ref.startswith(p), self.IGNORE_PREFIXES):
-                        if urlparse.urljoin(self.path, ref) not in self.localpaths:
+                        if urljoin(self.path, ref) not in self.localpaths:
                             raise Exception('Invalid reference %s in %s' % (ref, self.path))
             yield kind, data, pos
 
@@ -56,17 +55,16 @@ def __init__(self, src):
         OutputItem.__init__(self, src)
 
     def create(self, site, path):
-        f = open(self.src, 'r+b')
-        content = f.read()
-        f.close()
-        return content
+        with open(self.src, 'r+b') as f:
+            return f.read()
         
 class Page(OutputItem):
     def __init__(self, src):
         OutputItem.__init__(self, src)
 
     def create(self, site, path):
-        content = genshi.Stream(list(genshi.input.XMLParser(file(self.src))))
+        with open(self.src, encoding='ISO-8859-1') as f:
+            content = genshi.XML(f.read())
         def cond(c, a, b):
             if c:
                 return a
@@ -83,7 +81,7 @@ def cond(c, a, b):
         ))
         page = PAGE.generate(ctx)
         page |= LinkCheckFilter(path, site.localpaths())
-        return page.render('xhtml')
+        return page.render('xhtml', encoding='UTF-8')
         
 
 class NavigationNode(object):
@@ -127,22 +125,17 @@ def localpaths(self):
 
     def generate(self, basedir):
         bytesum = 0
-        items = self.items.items()
-        items.sort()
-        for (path, item) in items:
+        for (path, item) in sorted(self.items.items()):
             outpath = os.path.normpath(os.path.join(basedir, path))
             try:
                 os.makedirs(os.path.dirname(outpath))
             except:
                 pass
-            f = open(outpath, 'w+b')
             content = item.create(self, path)
-            f.write(content)
-            f.close()
+            with open(outpath, 'w+b') as f:
+                f.write(content)
             bytesum += len(content)
-            print '%6d bytes %s' % (len(content), path)
+            print('%6d bytes %s' % (len(content), path))
 
-        print '===================================================='
-        print '%6d bytes for %d files' % (bytesum, len(self.items))
-            
-            
\ No newline at end of file
+        print('====================================================')
+        print('%6d bytes for %d files' % (bytesum, len(self.items)))
diff --git a/render.sh b/render.sh
index b2924be..9da8778 100755
--- a/render.sh
+++ b/render.sh
@@ -14,5 +14,6 @@ mkdir $WORKING_DIR
 git clone -- $GIT_URL_ECLEMMA $CHECKOUT_PATH_ECLEMMA
 git -C $CHECKOUT_PATH_ECLEMMA checkout $BRANCH_ECLEMMA
 
-python2 generator/eclemmasite.py $RESULT_DIR
+pip install -r requirements.txt
+python3 generator/eclemmasite.py $RESULT_DIR
 
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..37b77b0
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1 @@
+Genshi==0.7.9
\ No newline at end of file