code: def _inner_convert_old_schema(self, node, depth):
          
          name, parameter_description = node
          if not isinstance(parameter_description, list):
              # This is a leaf, i.e., an actual L{Parameter} instance.
              return parameter_description
          if depth % 2 == 0:
              # we're processing a structure.
              fields = {}
              for node in parameter_description:
                  fields[node[0]] = self._inner_convert_old_schema(
                      node, depth + 1)
              return Structure(name, fields=fields)
          else:
              # we're processing a list.
              if not isinstance(parameter_description, list):
                  raise TypeError("node %r must be an associative list"
                                  % (parameter_description,))
              if not len(parameter_description) == 1:
                  raise ValueError(
                      "Multiple different index names specified: %r"
                      % ([item[0] for item in parameter_description],))
              subnode = parameter_description[0]
              item = self._inner_convert_old_schema(subnode, depth + 1)
              return List(name=name, item=item, optional=item.optional)
docs: Internal recursion helper for L{_convert_old_schema}.
  
          @param node: A node in the associative list tree as described in
              _convert_old_schema. A two tuple of (name, parameter).
          @param depth: The depth that the node is at. This is important to know
              if we're currently processing a list or a structure. ("foo.N" is a
              list called "foo", "foo.N.fieldname" describes a field in a list of
              structs).