docs: def _do_element(self, node, initial_other_attrs = [], unused = None):
          '''_do_element(self, node, initial_other_attrs = [], unused = {}) -> None
          Process an element (and its children).'''
  
          # Get state (from the stack) make local copies.
          #   ns_parent -- NS declarations in parent
          #   ns_rendered -- NS nodes rendered by ancestors
          #        ns_local -- NS declarations relevant to this element
          #   xml_attrs -- Attributes in XML namespace from parent
          #       xml_attrs_local -- Local attributes in XML namespace.
          #   ns_unused_inherited -- not rendered namespaces, used for exclusive 
          ns_parent, ns_rendered, xml_attrs = \
                  self.state[0], self.state[1].copy(), self.state[2].copy() #0422
                  
          ns_unused_inherited = unused
          if unused is None:
              ns_unused_inherited = self.state[3].copy()
              
          ns_local = ns_parent.copy()
          inclusive = _inclusive(self)
          xml_attrs_local = {}
  
          # Divide attributes into NS, XML, and others.
          other_attrs = []
          in_subset = _in_subset(self.subset, node)
          for a in initial_other_attrs + _attrs(node):
              if a.namespaceURI == XMLNS.BASE:
                  n = a.nodeName
                  if n == "xmlns:": n = "xmlns"        # DOM bug workaround
                  ns_local[n] = a.nodeValue
              elif a.namespaceURI == XMLNS.XML:
                  if inclusive or (in_subset and  _in_subset(self.subset, a)): #020925 Test to see if attribute node in subset
                      xml_attrs_local[a.nodeName] = a #0426
              else:
                  if  _in_subset(self.subset, a):     #020925 Test to see if attribute node in subset
                      other_attrs.append(a)
                      
  #                # TODO: exclusive, might need to define xmlns:prefix here
  #                if not inclusive and a.prefix is not None and not ns_rendered.has_key('xmlns:%s' %a.prefix):
  #                    ns_local['xmlns:%s' %a.prefix] = ??
  
              #add local xml:foo attributes to ancestor's xml:foo attributes
              xml_attrs.update(xml_attrs_local)
  
          # Render the node
          W, name = self.write, None
          if in_subset: 
              name = node.nodeName
              if not inclusive:
                  if node.prefix is not None:
                      prefix = 'xmlns:%s' %node.prefix
                  else:
                      prefix = 'xmlns'
                      
                  if not ns_rendered.has_key(prefix) and not ns_local.has_key(prefix):
                      if not ns_unused_inherited.has_key(prefix):
                          raise RuntimeError,\
                              'For exclusive c14n, unable to map prefix "%s" in %s' %(
                              prefix, node)
                      
                      ns_local[prefix] = ns_unused_inherited[prefix]
                      del ns_unused_inherited[prefix]
                  
              W('<')
              W(name)
  
              # Create list of NS attributes to render.
              ns_to_render = []
              for n,v in ns_local.items():
  
                  # If default namespace is XMLNS.BASE or empty,
                  # and if an ancestor was the same
                  if n == "xmlns" and v in [ XMLNS.BASE, '' ] \
                  and ns_rendered.get('xmlns') in [ XMLNS.BASE, '', None ]:
                      continue
  
                  # "omit namespace node with local name xml, which defines
                  # the xml prefix, if its string value is
                  # http://www.w3.org/XML/1998/namespace."
                  if n in ["xmlns:xml", "xml"] \
                  and v in [ 'http://www.w3.org/XML/1998/namespace' ]:
                      continue
  
  
                  # If not previously rendered
                  # and it's inclusive  or utilized
                  if (n,v) not in ns_rendered.items():
                      if inclusive or _utilized(n, node, other_attrs, self.unsuppressedPrefixes):
                          ns_to_render.append((n, v))
                      elif not inclusive:
                          ns_unused_inherited[n] = v
  
              # Sort and render the ns, marking what was rendered.
              ns_to_render.sort(_sorter_ns)
              for n,v in ns_to_render:
                  self._do_attr(n, v)
                  ns_rendered[n]=v    #0417
  
              # If exclusive or the parent is in the subset, add the local xml attributes
              # Else, add all local and ancestor xml attributes
              # Sort and render the attributes.
              if not inclusive or _in_subset(self.subset,node.parentNode):  #0426
                  other_attrs.extend(xml_attrs_local.values())
              else:
                  other_attrs.extend(xml_attrs.values())
              other_attrs.sort(_sorter)
              for a in other_attrs:
                  self._do_attr(a.nodeName, a.value)
              W('>')
  
          # Push state, recurse, pop state.
          state, self.state = self.state, (ns_local, ns_rendered, xml_attrs, ns_unused_inherited)
          for c in _children(node):
              _implementation.handlers[c.nodeType](self, c)
          self.state = state
  
          if name: W('</%s>' % name)