[Zope3-checkins] CVS: Zope/lib/python/ZConfig - cfgparser.py:1.1.4.1 datatypes.py:1.1.4.1 info.py:1.1.4.1 loader.py:1.1.4.1 matcher.py:1.1.4.1 schema.py:1.1.4.1 substitution.py:1.1.4.1 url.py:1.1.4.1 BRANCHES.txt:1.1.4.2 Config.py:1.2.4.7 Context.py:1.1.4.7 __init__.py:1.1.4.9

Chris McDonough chrism@zope.com
Fri, 3 Jan 2003 10:52:34 -0500


Update of /cvs-repository/Zope/lib/python/ZConfig
In directory cvs.zope.org:/tmp/cvs-serv2937

Modified Files:
      Tag: chrism-install-branch
	BRANCHES.txt Config.py Context.py __init__.py 
Added Files:
      Tag: chrism-install-branch
	cfgparser.py datatypes.py info.py loader.py matcher.py 
	schema.py substitution.py url.py 
Log Message:
Merge zconfig-schema-devel-branch into chrism-install-branch.  Why not? ;-)


=== Added File Zope/lib/python/ZConfig/cfgparser.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Configuration parser."""

from ZConfig import ConfigurationError, ConfigurationSyntaxError
from ZConfig.substitution import isname, substitute
from ZConfig.url import urljoin

try:
    True
except NameError:
    True = 1
    False = 0


class ZConfigParser:
    def __init__(self, resource, context):
        self.resource = resource
        self.context = context
        self.file = resource.file
        self.url = resource.url
        self.lineno = 0
        self.stack = []   # [(type, name, delegatename, prevmatcher), ...]
        self.defs = {}

    def nextline(self):
        line = self.file.readline()
        if line:
            self.lineno += 1
            return False, line.strip()
        else:
            return True, None

    def parse(self, section):
        done, line = self.nextline()
        while not done:
            if line[:1] in ("", "#"):
                # blank line or comment
                pass

            elif line[:2] == "</":
                # section end
                if line[-1] != ">":
                    self.error("malformed section end")
                section = self.end_section(section, line[2:-1])

            elif line[0] == "<":
                # section start
                if line[-1] != ">":
                    self.error("malformed section start")
                section = self.start_section(section, line[1:-1])

            elif line[0] == "%":
                self.handle_directive(section, line[1:])

            else:
                self.handle_key_value(section, line)

            done, line = self.nextline()

        if self.stack:
            self.error("unclosed sections not allowed")

    def start_section(self, section, rest):
        isempty = rest[-1:] == "/"
        if isempty:
            text = rest[:-1].rstrip()
        else:
            text = rest.rstrip()
        # parse section start stuff here
        m = _section_start_rx.match(text)
        if not m:
            self.error("malformed section header")
        type, name, delegatename = m.group('type', 'name', 'delegatename')
        type = type.lower()
        if name:
            name = name.lower()
        try:
            newsect = self.context.startSection(section, type, name,
                                                delegatename)
        except ConfigurationError, e:
            self.error(e[0])

        if isempty:
            self.context.endSection(section, type, name, delegatename, newsect)
            return section
        else:
            self.stack.append((type, name, delegatename, section))
            return newsect

    def end_section(self, section, rest):
        if not self.stack:
            self.error("unexpected section end")
        type = rest.rstrip().lower()
        opentype, name, delegatename, prevsection = self.stack.pop()
        if type != opentype:
            self.error("unbalanced section end")
        try:
            self.context.endSection(
                prevsection, type, name, delegatename, section)
        except ConfigurationError, e:
            self.error(e[0])
        return prevsection

    def handle_key_value(self, section, rest):
        m = _keyvalue_rx.match(rest)
        if not m:
            self.error("malformed configuration data")
        key, value = m.group('key', 'value')
        if not value:
            value = ''
        else:
            value = substitute(value, self.defs)
        try:
            section.addValue(key, value)
        except ConfigurationError, e:
            self.error(e[0])

    def handle_directive(self, section, rest):
        m = _keyvalue_rx.match(rest)
        if not m:
            self.error("missing or unrecognized directive")
        name, arg = m.group('key', 'value')
        if name not in ("define", "include"):
            self.error("unknown directive: " + `name`)
        if not arg:
            self.error("missing argument to %%%s directive" % name)
        if name == "include":
            self.handle_include(section, arg)
        elif name == "define":
            self.handle_define(section, arg)
        else:
            assert 0, "unexpected directive for " + `"%" + rest`

    def handle_include(self, section, rest):
        newurl = urljoin(self.url, rest)
        self.context.includeConfiguration(section, newurl)

    def handle_define(self, section, rest):
        parts = rest.split(None, 1)
        defname = parts[0].lower()
        defvalue = ''
        if len(parts) == 2:
            defvalue = parts[1]
        if self.defs.has_key(defname):
            self.error("cannot redefine " + `defname`)
        if not isname(defname):
            self.error("not a substitution legal name: " + `defname`)
        self.defs[defname] = defvalue

    def error(self, message):
        raise ConfigurationSyntaxError(message, self.url, self.lineno)


import re
# _name_re cannot allow "(" or ")" since we need to be able to tell if
# a section has a name or not: <section (name)> would be ambiguous if
# parentheses were allowed in names.
_name_re = r"[^\s()]+"
_keyvalue_rx = re.compile(r"(?P<key>%s)\s*(?P<value>[^\s].*)?$"
                          % _name_re)
_section_start_rx = re.compile(r"(?P<type>%s)"
                               r"(?:\s+(?P<name>%s))?"
                               r"(?:\s*[(](?P<delegatename>%s)[)])?"
                               r"$"
                               % (_name_re, _name_re, _name_re))
del re


=== Added File Zope/lib/python/ZConfig/datatypes.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Selection of standard datatypes for ZConfig."""

import re
import sys
import os

try:
    True
except NameError:
    True = 1
    False = 0


class MemoizedConversion:
    """Conversion helper that caches the results of expensive conversions."""

    def __init__(self, conversion):
        self._memo = {}
        self._conversion = conversion

    def __call__(self, value):
        try:
            return self._memo[value]
        except KeyError:
            v = self._conversion(value)
            self._memo[value] = v
            return v


class RangeCheckedConversion:
    """Conversion helper that range checks another conversion."""

    def __init__(self, conversion, min=None, max=None):
        self._min = min
        self._max = max
        self._conversion = conversion

    def __call__(self, value):
        v = self._conversion(value)
        if self._min is not None and v < self._min:
            raise ValueError("%s is below lower bound (%s)"
                             % (`v`, `self._min`))
        if self._max is not None and v > self._max:
            raise ValueError("%s is above upper bound (%s)"
                             % (`v`, `self._max`))
        return v


class RegularExpressionConversion:
    def __init__(self, regex):
        self._rx = re.compile(regex)

    def __call__(self, value):
        m = self._rx.match(value)
        if m and m.group() == value:
            return value
        else:
            raise ValueError("value did not match regular expression: "
                             + `value`)


def check_locale(value):
    import locale
    prev = locale.setlocale(locale.LC_ALL)
    try:
        try:
            locale.setlocale(locale.LC_ALL, value)
        finally:
            locale.setlocale(locale.LC_ALL, prev)
    except locale.Error:
        raise ValueError(
            'The specified locale "%s" is not supported by your system.\n'
            'See your operating system documentation for more\n'
            'information on locale support.' % value)
    else:
        return value


class BasicKeyConversion(RegularExpressionConversion):
    def __init__(self):
        RegularExpressionConversion.__init__(self, "[a-zA-Z][-._a-zA-Z0-9]*")

    def __call__(self, value):
        value = str(value)
        return RegularExpressionConversion.__call__(self, value).lower()


class IdentifierConversion(RegularExpressionConversion):
    def __init__(self):
        RegularExpressionConversion.__init__(self, "[_a-zA-Z][_a-zA-Z0-9]*")


class LogLevelConversion:
    # This uses the 'logging' package conventions; only makes sense
    # for Zope 2.7 (and newer) and Zope 3.  Not sure what the
    # compatibility should be.

    _levels = {
        "critical": 50,
        "fatal": 50,
        "error": 40,
        "warn": 30,
        "info": 20,
        "debug": 10,
        "all": 0,
        }

    def __call__(self, value):
        s = str(value).lower()
        if self._levels.has_key(s):
            return self._levels[s]
        else:
            v = int(s)
            if v < 0 or v > 50:
                raise ValueError("log level not in range: " + `v`)
            return v


if sys.version[:3] < "2.3":
    def integer(value):
        try:
            return int(value)
        except ValueError:
            return long(value)
else:
    integer = int


def null_conversion(value):
    return value


def asBoolean(s):
    """Convert a string value to a boolean value."""
    ss = str(s).lower()
    if ss in ('yes', 'true', 'on'):
        return True
    elif ss in ('no', 'false', 'off'):
        return False
    else:
        raise ValueError("not a valid boolean value: " + repr(s))


port_number = RangeCheckedConversion(integer, min=1, max=0xffff).__call__


def inet_address(s):
    # returns (host, port) tuple
    host = ''
    port = None
    if ":" in s:
        host, s = s.split(":", 1)
        if s:
            port = port_number(s)
        host = host.lower()
    else:
        try:
            port = port_number(s)
        except ValueError:
            host = s.lower()
    return host, port


def socket_address(s):
    # returns (family, address) tuple
    import socket
    if "/" in s:
        if hasattr(socket, "AF_UNIX"):
            return socket.AF_UNIX, s
        else:
            raise ValueError(
                "AF_UNIX sockets are not supported on this platform")
    else:
        return socket.AF_INET, inet_address(s)

def float_conversion(v):
    if isinstance(v, type('')) or isinstance(v, type(u'')):
        if v.lower() in ["inf", "-inf", "nan"]:
            raise ValueError(`v` + " is not a portable float representation")
    return float(v)

class IpaddrOrHostname(RegularExpressionConversion):
    def __init__(self):
        # IP address regex from the Perl Cookbook, Recipe 6.23 (revised ed.)
        # We allow underscores in hostnames although this is considered
        # illegal according to RFC1034.
        expr = (r"(^(\d|[01]?\d\d|2[0-4]\d|25[0-5])\." #ipaddr
                r"(\d|[01]?\d\d|2[0-4]\d|25[0-5])\." #ipaddr cont'd
                r"(\d|[01]?\d\d|2[0-4]\d|25[0-5])\." #ipaddr cont'd
                r"(\d|[01]?\d\d|2[0-4]\d|25[0-5])$)" #ipaddr cont'd
                r"|([^0-9][A-Za-z0-9-_.]+)") # or hostname
        RegularExpressionConversion.__init__(self, expr)

def existing_directory(v):
    if os.path.isdir(v):
        return v
    raise ValueError, '%s is not an existing directory' % v

def existing_path(v):
    if os.path.exists(v):
        return v
    raise ValueError, '%s is not an existing path' % v

def existing_file(v):
    if os.path.exists(v):
        return v
    raise ValueError, '%s is not an existing file' % v

def existing_dirpath(v):
    if not os.path.split(v)[0]:
        # relative pathname
        return v
    dir = os.path.dirname(v)
    if os.path.isdir(dir):
        return v
    raise ValueError, ('The directory named as part of the path %s '
                       'does not exist.' % v)

def parse_constructor(v):
    parenmsg = (
        'Invalid constructor (unbalanced parenthesis in "%s")' % v
        )
    openparen = v.find('(')
    if openparen < 0:
        raise ValueError(parenmsg)
    klass = v[:openparen]
    if not v.endswith(')'):
        raise ValueError(parenmsg)
    arglist = v[openparen+1:-1]
    return klass, arglist

def get_arglist(s):
    # someone could do a better job at this.
    pos = []
    kw = {}
    args = s.split(',')
    args = filter(None, args)
    while args:
        arg = args.pop(0)
        try:
            if '=' in arg:
                k,v=arg.split('=', 1)
                k = k.strip()
                v = v.strip()
                kw[k] = eval(v)
            else:
                arg = arg.strip()
                pos.append(eval(arg))
        except SyntaxError:
            if not args:
                raise
            args[0] = '%s, %s' % (arg, args[0])
    return pos, kw

def constructor_conversion(v):
    klass, arglist = parse_constructor(v)
    pos, kw = get_arglist(arglist)
    return klass, pos, kw

def space_sep_key_value_conversion(v):
    l = v.split(' ', 1)
    if len(l) < 2:
        l.append('')
    return l

stock_datatypes = {
    "boolean":       asBoolean,
    "identifier":    IdentifierConversion().__call__,
    "integer":       integer,
    "float":         float_conversion,
    "string":        str,
    "null":          null_conversion,
    "locale":        MemoizedConversion(check_locale).__call__,
    "port-number":   port_number,
    "basic-key":     BasicKeyConversion().__call__,
    "logging-level": LogLevelConversion().__call__,
    "inet-address":  inet_address,
    "socket-address":socket_address,
    "ipaddr-or-hostname":IpaddrOrHostname().__call__,
    "existing-directory":existing_directory,
    "existing-path":existing_path,
    "existing-file":existing_file,
    "existing-dirpath":existing_dirpath,
    "constructor":constructor_conversion,
    "key-value":space_sep_key_value_conversion,
    }

class Registry:
    def __init__(self, stock=None):
        if stock is None:
            stock = stock_datatypes.copy()
        self._stock = stock
        self._other = {}

    def get(self, name):
        t = self._stock.get(name)
        if t is None:
            t = self._other.get(name)
            if t is None:
                t = self.search(name)
        return t

    def register(self, name, conversion):
        if self._stock.has_key(name):
            raise ValueError("datatype name conflicts with built-in type: "
                             + `name`)
        if self._other.has_key(name):
            raise ValueError("datatype name already registered:" + `name`)
        self._other[name] = conversion

    def search(self, name):
        if not "." in name:
            raise ValueError("unloadable datatype name: " + `name`)
        components = name.split('.')
        start = components[0]
        g = globals()
        package = __import__(start, g, g)
        modulenames = [start]
        for component in components[1:]:
            modulenames.append(component)
            try:
                package = getattr(package, component)
            except AttributeError:
                n = '.'.join(modulenames)
                package = __import__(n, g, g, component)
        self._other[name] = package
        return package


=== Added File Zope/lib/python/ZConfig/info.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Objects that can describe a ZConfig schema."""

import ZConfig


try:
    True
except NameError:
    True = 1
    False = 0


class UnboundedThing:
    def __lt__(self, other):
        return False

    def __le__(self, other):
        return isinstance(other, self.__class__)

    def __gt__(self, other):
        return True

    def __ge__(self, other):
        return True

    def __eq__(self, other):
        return isinstance(other, self.__class__)

    def __ne__(self, other):
        return not isinstance(other, self.__class__)

    def __repr__(self):
        return "<Unbounded>"

Unbounded = UnboundedThing()


class BaseInfo:
    """Information about a single configuration key."""

    description = None
    example = None
    metadefault = None

    def __init__(self, name, datatype, minOccurs, maxOccurs, handler,
                 attribute):
        if maxOccurs is not None and maxOccurs < 1:
            if maxOccurs < 1:
                raise ZConfig.SchemaError(
                    "maxOccurs must be at least 1")
            if minOccurs is not None and minOccurs < maxOccurs:
                raise ZConfig.SchemaError(
                    "minOccurs must be at least maxOccurs")
        self.name = name
        self.datatype = datatype
        self.minOccurs = minOccurs
        self.maxOccurs = maxOccurs
        self.handler = handler
        self.attribute = attribute

    def __repr__(self):
        clsname = self.__class__.__name__
        return "<%s for %s>" % (clsname, `self.name`)

    def istypegroup(self):
        return False

    def ismulti(self):
        return self.maxOccurs > 1

    def issection(self):
        return False


class KeyInfo(BaseInfo):
    def __init__(self, name, datatype, minOccurs, maxOccurs, handler,
                 attribute):
        assert minOccurs is not None
        BaseInfo.__init__(self, name, datatype, minOccurs, maxOccurs,
                          handler, attribute)
        self._finished = False
        self._default = None

    def finish(self):
        if self._finished:
            raise ZConfig.SchemaError(
                "cannot finish KeyInfo more than once")
        self._finished = True

    def adddefault(self, value):
        if self._finished:
            raise ZConfig.SchemaError(
                "cannot add default values to finished KeyInfo")
        if self.maxOccurs > 1:
            if self._default is None:
                self._default = [value]
            else:
                self._default.append(value)
        elif self._default is not None:
            raise ZConfig.SchemaError(
                "cannot set more than one default to key with maxOccurs == 1")
        else:
            self._default = value

    def getdefault(self):
        if not self._finished:
            raise ZConfig.SchemaError(
                "cannot get default value of key before KeyInfo"
                " has been completely initialized")
        if self._default is None and self.maxOccurs > 1:
            return []
        else:
            return self._default


class SectionInfo(BaseInfo):
    def __init__(self, name, sectiontype, minOccurs, maxOccurs, handler,
                 attribute):
        # name        - name of the section; one of '*', '+', or name1
        # sectiontype - SectionType instance
        # minOccurs   - minimum number of occurances of the section
        # maxOccurs   - maximum number of occurances; if > 1, name
        #               must be '*' or '+'
        # handler     - handler name called when value(s) must take effect,
        #               or None
        # attribute   - name of the attribute on the SectionValue object
        if maxOccurs > 1:
            if name not in ('*', '+'):
                raise ZConfig.SchemaError(
                    "sections which can occur more than once must"
                    " use a name of '*' or '+'")
            if not attribute:
                raise ZConfig.SchemaError(
                    "sections which can occur more than once must"
                    " specify a target attribute name")
        if sectiontype.istypegroup():
            datatype = None
        else:
            datatype = sectiontype.datatype
        BaseInfo.__init__(self, name, datatype,
                          minOccurs, maxOccurs, handler, attribute)
        self.sectiontype = sectiontype

    def __repr__(self):
        clsname = self.__class__.__name__
        return "<%s for %s (%s)>" % (
            clsname, self.sectiontype.name, `self.name`)

    def issection(self):
        return True

    def allowUnnamed(self):
        return self.name == "*"

    def isAllowedName(self, name):
        if name == "*" or name == "+":
            return False
        elif self.name == "+":
            return name and True or False
        elif not name:
            return self.name == "*"
        else:
            return name == self.name

    def getdefault(self):
        # sections cannot have defaults
        if self.maxOccurs > 1:
            return []
        else:
            return None

class TypeContainer:
    def __init__(self):
        self._types = {}

    def addtype(self, typeinfo):
        n = typeinfo.name.lower()
        if self._types.has_key(n):
            raise ZConfig.SchemaError("type name cannot be redefined: "
                                             + `typeinfo.name`)
        self._types[n] = typeinfo

    def gettype(self, name):
        n = name.lower()
        try:
            return self._types[n]
        except KeyError:
            raise ZConfig.SchemaError("unknown type name: " + `name`)

    def gettypenames(self):
        return self._types.keys()

    def finish(self):
        if not self._types:
            raise ZConfig.SchemaError(
                "sectiongroup must contain at least on sectiontype")


class GroupType(TypeContainer):
    def __init__(self, name):
        TypeContainer.__init__(self)
        self.name = name

    def istypegroup(self):
        return True


class SectionType:
    def __init__(self, name, keytype, valuetype, datatype):
        # name      - name of the section, or '*' or '+'
        # datatype  - type for the section itself
        # keytype   - type for the keys themselves
        # valuetype - default type for key values
        self.name = name
        self.datatype = datatype
        self.keytype = keytype
        self.valuetype = valuetype
        self._children = []    # [(key, info), ...]
        self._attrmap = {}     # {attribute: index, ...}
        self._keymap = {}      # {key: index, ...}

    def __len__(self):
        return len(self._children)

    def __getitem__(self, index):
        return self._children[index]

    def _add_child(self, key, info):
        # check naming constraints
        assert key or info.attribute
        if key and self._keymap.has_key(key):
            raise ZConfig.SchemaError(
                "child name %s already used" % key)
        if info.attribute and self._attrmap.has_key(info.attribute):
            raise ZConfig.SchemaError(
                "child attribute name %s already used" % info.attribute)
        # a-ok, add the item to the appropriate maps
        if info.attribute:
            self._attrmap[info.attribute] = len(self._children)
        if key:
            self._keymap[key] = len(self._children)
        self._children.append((key, info))

    def addkey(self, keyinfo):
        self._add_child(keyinfo.name, keyinfo)

    def addsection(self, name, sectinfo):
        assert name not in ("*", "+")
        self._add_child(name, sectinfo)

    def getinfo(self, key):
        if not key:
            raise ZConfig.ConfigurationError(
                "cannot match a key without a name")
        index = self._keymap.get(key)
        if index is None:
            raise ZConfig.ConfigurationError("no key matching " + `key`)
        else:
            return self._children[index][1]

    def getchildnames(self):
        return [key for (key, info) in self._children]

    def getrequiredtypes(self):
        d = {}
        if self.name:
            d[self.name] = 1
        stack = [self]
        while stack:
            info = stack.pop()
            for key, ci in info._children:
                if ci.issection():
                    t = ci.sectiontype
                    if not d.has_key(t.name):
                        d[t.name] = 1
                        stack.append(t)
        return d.keys()

    def getsectionindex(self, type, name):
        index = -1
        for key, info in self._children:
            index += 1
            if key:
                if key == name:
                    if not info.issection():
                        raise ZConfig.ConfigurationError(
                            "section name %s already in use for key" % key)
                    st = info.sectiontype
                    if st.istypegroup():
                        try:
                            st = st.gettype(type)
                        except ZConfig.ConfigurationError:
                            raise ZConfig.ConfigurationError(
                                "section type %s not allowed for name %s"
                                % (`type`, `key`))
                    if not st.name == type:
                        raise ZConfig.ConfigurationError(
                            "name %s must be used for a %s section"
                            % (`name`, `st.name`))
                    return index
            # else must be a section or a sectiongroup:
            elif info.sectiontype.name == type:
                if not (name or info.allowUnnamed()):
                    raise ZConfig.ConfigurationError(
                        `type` + " sections must be named")
                return index
            elif info.sectiontype.istypegroup():
                st = info.sectiontype
                if st.name == type:
                    raise ZConfig.ConfigurationError(
                        "cannot define section with a sectiongroup type")
                try:
                    st = st.gettype(type)
                except ZConfig.ConfigurationError:
                    # not this one; maybe a different one
                    pass
                else:
                    return index
        raise ZConfig.ConfigurationError("no matching section defined")

    def getsectioninfo(self, type, name):
        i = self.getsectionindex(type, name)
        st = self._children[i][1]
        if st.istypegroup():
            st = st.gettype(type)
        return st

    def istypegroup(self):
        return False


class SchemaType(TypeContainer, SectionType):
    def __init__(self, name, keytype, valuetype, datatype, handler, url):
        SectionType.__init__(self, name, keytype, valuetype, datatype)
        TypeContainer.__init__(self)
        self.handler = handler
        self.url = url

    def allowUnnamed(self):
        return True

    def isAllowedName(self, name):
        return False

    def issection(self):
        return True

    def getunusedtypes(self):
        alltypes = self.gettypenames()
        reqtypes = self.getrequiredtypes()
        for n in reqtypes:
            alltypes.remove(n)
        if self.name and self.name in alltypes:
            alltypes.remove(self.name)
        return alltypes


=== Added File Zope/lib/python/ZConfig/loader.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Schema loader utility."""

import os.path
import urllib
import urllib2

import ZConfig

from ZConfig import datatypes
from ZConfig import matcher
from ZConfig.url import urlnormalize, urldefrag, urljoin, urlsplit, urlunsplit

try:
    True
except NameError:
    True = 1
    False = 0


RESOURCE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                            "resources")


def loadSchema(url):
    return SchemaLoader().loadURL(url)

def loadSchemaFile(file, url=None):
    return SchemaLoader().loadFile(file, url)

def loadConfig(schema, url):
    return ConfigLoader(schema).loadURL(url)

def loadConfigFile(schema, file, url=None):
    return ConfigLoader(schema).loadFile(file, url)


class BaseLoader:
    def __init__(self):
        pass

    def createResource(self, file, url, fragment=None):
        return Resource(file, url, fragment)

    def loadURL(self, url):
        url = self.normalizeURL(url)
        r = self.openResource(url)
        try:
            return self.loadResource(r)
        finally:
            r.close()

    def loadFile(self, file, url=None):
        if not url:
            url = _url_from_file(file)
        r = self.createResource(file, url)
        return self.loadResource(r)

    # utilities

    def loadResource(self, resource):
        raise NotImpementedError(
            "BaseLoader.loadResource() must be overridden by a subclass")

    def openResource(self, url):
        # XXX This should be replaced to use a local cache for remote
        # resources.  The policy needs to support both re-retrieve on
        # change and provide the cached resource when the remote
        # resource is not accessible.
        parts = list(urlsplit(url))
        fragment = parts[-1]
        if fragment:
            parts[-1] = ''
            url = urlunsplit(tuple(parts))
        if parts[0] == 'zconfig':
            file = _open_resource_file(url)
        else:
            file = urllib2.urlopen(url)
        return self.createResource(file, url, fragment or None)

    def normalizeURL(self, url):
        if os.path.exists(url):
            url = "file://" + urllib.pathname2url(os.path.abspath(url))
        else:
            url = urlnormalize(url)
        if url and not self.allowFragments():
            url, fragment = urldefrag(url)
            if fragment:
                raise ZConfig.ConfigurationError(
                    "fragment identifiers are not supported")
        return url

    def allowFragments(self):
        return False


def _url_from_file(file):
    name = getattr(file, "name", None)
    if name and name[0] != "<" and name[-1] != ">":
        return "file://" + urllib.pathname2url(os.path.abspath(name))
    else:
        return None


def _open_resource_file(url):
    parts = urlsplit(url)
    assert parts[0] == 'zconfig'
    fn = os.path.join(RESOURCE_DIR, parts[2])
    if not os.path.isfile(fn):
        raise ValueError("no such resource: " + `parts[2]`)
    return open(fn)


class SchemaLoader(BaseLoader):
    def __init__(self, registry=None):
        if registry is None:
            registry = datatypes.Registry()
        self.registry = registry
        self._cache = {}
        BaseLoader.__init__(self)

    def loadResource(self, resource):
        if resource.url and self._cache.has_key(resource.url):
            schema = self._cache[resource.url]
        else:
            from ZConfig.schema import parseResource
            schema = parseResource(resource, self.registry, self)
            self._cache[resource.url] = schema
        if resource.fragment:
            type = self.registry.get("basic-key")(resource.fragment)
            schema = schema.gettype(type)
        return schema

    def allowFragments(self):
        return True


class ConfigLoader(BaseLoader):
    def __init__(self, schema):
        BaseLoader.__init__(self)
        self.schema = schema

    def loadResource(self, resource):
        self.handlers = []
        sm = matcher.SchemaMatcher(self.schema, self.handlers)
        self._parse_resource(sm, resource)
        return sm.finish(), CompositeHandler(self.handlers, self.schema)

    # parser support API

    def startSection(self, parent, type, name, delegatename):
        if delegatename:
            raise NotImpementedError("section delegation is not yet supported")
        t = self.schema.gettype(type)
        if t.istypegroup():
            raise ZConfig.ConfigurationError(
                "concrete sections cannot match abstract section types;"
                " found abstract type " + `type`)
        info = parent.info
        info = getattr(info, "sectiontype", info)
        ci = info.getsectioninfo(type, name)
        assert not ci.istypegroup()
        if not ci.isAllowedName(name):
            raise ZConfig.ConfigurationError(
                "%s is not an allowed name for %s sections"
                % (`name`, `ci.sectiontype.name`))
        return matcher.SectionMatcher(ci, t, name, self.handlers)

    def endSection(self, parent, type, name, delegatename, matcher):
        assert not delegatename
        sectvalue = matcher.finish()
        parent.addSection(type, name, sectvalue)

    def includeConfiguration(self, section, url):
        r = self.openResource(url)
        self._parse_resource(section, r)

    # internal helper

    def _parse_resource(self, matcher, resource):
        from ZConfig.cfgparser import ZConfigParser
        parser = ZConfigParser(resource, self)
        parser.parse(matcher)


class CompositeHandler:
    def __init__(self, handlers, schema):
        self._handlers = handlers
        self._convert = schema.registry.get("basic-key")

    def __call__(self, handlermap):
        d = {}
        for name, callback in handlermap.items():
            n = self._convert(name)
            if d.has_key(n):
                raise ZConfig.ConfigurationError(
                    "handler name not unique when converted to a basic-key: "
                    + `name`)
            d[n] = callback
        L = []
        for handler, value in self._handlers:
            if not d.has_key(handler):
                L.append(handler)
        if L:
            raise ZConfig.ConfigurationError(
                "undefined handlers: " + ", ".join(L))
        for handler, value in self._handlers:
            f = d[handler]
            if f is not None:
                f(value)

    def __len__(self):
        return len(self._handlers)


class Resource:
    def __init__(self, file, url, fragment=None):
        self.file = file
        self.url = url
        self.fragment = fragment

    def close(self):
        if self.file is not None:
            self.file.close()
            self.file = None
            self.closed = True

    def __getattr__(self, name):
        return getattr(self.file, name)


=== Added File Zope/lib/python/ZConfig/matcher.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Utility that manages the binding of configuration data to a section."""

import types

import ZConfig


class BaseMatcher:
    def __init__(self, info, type, handlers):
        self.info = info
        self.type = type
        self._values = [None] * len(type)
        self._sectionnames = {}
        if handlers is None:
            handlers = []
        self._handlers = handlers

    def __repr__(self):
        clsname = self.__class__.__name__
        return "<%s for >" % (clsname, )

    def addSection(self, type, name, sectvalue):
        if name:
            if self._sectionnames.has_key(name):
                raise ZConfig.ConfigurationError(
                    "section names must not be re-used within the"
                    " same container:" + `name`)
            self._sectionnames[name] = name
        i = self.type.getsectionindex(type, name)
        ci = self.type.getsectioninfo(type, name)
        v = self._values[i]
        if v is None:
            if ci.ismulti():
                self._values[i] = [sectvalue]
            else:
                self._values[i] = sectvalue
        elif ci.ismulti():
            v.append(sectvalue)
        else:
            raise ZConfig.ConfigurationError(
                "too many instances of %s section" % `ci.sectiontype.name`)

    def addValue(self, key, value):
        length = len(self.type)
        arbkey_info = None
        for i in range(length):
            k, ci = self.type[i]
            if k == key:
                break
            if ci.name == "+" and not ci.issection():
                arbkey_info = i, k, ci
        else:
            if arbkey_info is None:
                raise ZConfig.ConfigurationError(
                    `key` + " is not a known key name")
            i, k, ci = arbkey_info
        if ci.issection():
            if ci.name:
                extra = " in %s sections" % `self.type.name`
            else:
                extra = ""
            raise ZConfig.ConfigurationError(
                "%s is not a valid key name%s" % (`key`, extra))

        ismulti = ci.ismulti()
        v = self._values[i]
        if v is None:
            if k == '+':
                v = {}
            elif ismulti:
                v = []
            self._values[i] = v
        elif not ismulti:
            if k != '+':
                raise ZConfig.ConfigurationError(
                    `key` + " does not support multiple values")
        elif len(v) == ci.maxOccurs:
            raise ZConfig.ConfigurationError(
                "too many values for " + `name`)

        if k == '+':
            if ismulti:
                if v.has_key(key):
                    v[key].append(value)
                else:
                    v[key] = [value]
            else:
                if v.has_key(key):
                    raise ZConfig.ConfigurationError("too many")
                v[key] = value
        elif ismulti:
            v.append(value)
        else:
            self._values[i] = value

    def finish(self):
        """Check the constraints of the section and convert to an application
        object."""
        length = len(self.type)
        values = self._values
        attrnames = [None] * length
        for i in range(length):
            key, ci = self.type[i]
            attrnames[i] = ci.attribute or key
            v = values[i]
            if v is None and ci.name == '+' and not ci.issection():
                if ci.minOccurs > 0:
                    raise ZConfig.ConfigurationError(
                        "no keys defined for the %s key/value map; at least %d"
                        " must be specified" % (ci.attribute, ci.minOccurs))
                v = {}
                values[i] = v
            if v is None and ci.minOccurs:
                default = ci.getdefault()
                if default is None:
                    if key:
                        s = `key`
                    else:
                        s = "section type " + `ci.typename`
                    raise ZConfig.ConfigurationError(
                        "no values for %s; %s required" % (s, ci.minOccurs))
                else:
                    v = values[i] = default[:]
            if ci.ismulti():
                if v is None:
                    v = values[i] = ci.getdefault()[:]
                if len(v) < ci.minOccurs:
                    raise ZConfig.ConfigurationError(
                        "not enough values for %s; %d found, %d required"
                        % (`key`, len(v), ci.minOccurs))
            if v is None and not ci.issection():
                if ci.ismulti():
                    v = ci.getdefault()[:]
                else:
                    v = ci.getdefault()
                values[i] = v
        return self.constuct(attrnames)

    def constuct(self, attrnames):
        values = self._values
        for i in range(len(values)):
            name, ci = self.type[i]
            if ci.ismulti():
                if ci.issection():
                    v = []
                    for s in values[i]:
                        if s is not None:
                            v.append(s._type.datatype(s))
                        else:
                            v.append(None)
                elif ci.name == '+':
                    v = values[i]
                    for key, val in v.items():
                        v[key] = [ci.datatype(s) for s in val]
                else:
                    v = [ci.datatype(s) for s in values[i]]
            elif ci.issection():
                if values[i] is not None:
                    v = values[i]._type.datatype(values[i])
                else:
                    v = None
            elif name == '+':
                v = values[i]
                for key, val in v.items():
                    v[key] = ci.datatype(val)
            else:
                v = values[i]
                if v is not None:
                    v = ci.datatype(v)
            values[i] = v
            if ci.handler is not None:
                self._handlers.append((ci.handler, v))
        return self.createValue(attrnames)

    def createValue(self, attrnames):
        return SectionValue(attrnames, self._values, None, self.type)


class SectionMatcher(BaseMatcher):
    def __init__(self, info, type, name, handlers):
        if name or info.allowUnnamed():
            self.name = name
        else:
            raise ZConfig.ConfigurationError(
                `type.name` + " sections may not be unnamed")
        BaseMatcher.__init__(self, info, type, handlers)

    def createValue(self, attrnames):
        return SectionValue(attrnames, self._values, self.name, self.type)


class SchemaMatcher(BaseMatcher):
    def __init__(self, info, handlers=None):
        BaseMatcher.__init__(self, info, info, handlers)

    def finish(self):
        # Since there's no outer container to call datatype()
        # for the schema, we convert on the way out.
        v = BaseMatcher.finish(self)
        v = self.type.datatype(v)
        if self.type.handler is not None:
            self._handlers.append((self.type.handler, v))
        return v


class SectionValue:
    """Generic 'bag-of-values' object for a section.

    Derived classes should always call the SectionValue constructor
    before attempting to modify self.
    """

    def __init__(self, attrnames, values, name, type):
        d = self.__dict__
        d['_attrnames'] = attrnames
        d['_values'] = values
        d['_name'] = name
        d['_type'] = type

    def __repr__(self):
        if self._name:
            # probably unique for a given config file; more readable than id()
            name = `self._name`
        else:
            # identify uniquely
            name = "at %#x" % id(self)
        clsname = self.__class__.__name__
        return "<%s for %s %s>" % (clsname, self._type.name, name)

    def __len__(self):
        return len(self._values)

    def __getitem__(self, index):
        if isinstance(index, types.SliceType):
            raise TypeError("SectionValue does not support slicing")
        return self._values[index]

    def __setitem__(self, index, value):
        if isinstance(index, types.SliceType):
            raise TypeError("SectionValue does not support slicing")
        self._values[index] = value

    def __getattr__(self, name):
        try:
            i = self._attrnames.index(name)
        except ValueError:
            raise AttributeError, name
        return self._values[i]

    def __setattr__(self, name, value):
        try:
            i = self._attrnames.index(name)
        except ValueError:
            self.__dict__[name] = value
        else:
            self._values[i] = value

    def __str__(self):
        l = []
        for i in range(len(self._attrnames)):
            k = self._attrnames[i]
            v = self._values[i]
            l.append('%-40s: %s' % (k, v))
        return '\n'.join(l)

    def getSectionName(self):
        return self._name

    def getSectionType(self):
        return self._type.name


=== Added File Zope/lib/python/ZConfig/schema.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Parser for ZConfig schemas."""

import xml.sax
import xml.sax.saxutils

import ZConfig

from ZConfig import info
from ZConfig import url


try:
    True
except NameError:
    True = 1
    False = 0

try:
    dict
except NameError:
    def dict(mapping):
        d = {}
        for k, v in mapping.items():
            d[k] = v
        return d


def parseResource(resource, registry, loader):
    parser = SchemaParser(registry, loader, resource.url)
    xml.sax.parse(resource.file, parser)
    return parser._schema


class SchemaParser(xml.sax.ContentHandler):

    _cdata_tags = "description", "metadefault", "example", "default"
    _handled_tags = ("schema", "import", "sectiongroup", "sectiontype",
                     "key", "multikey", "section", "multisection")

    def __init__(self, registry, loader, url):
        self._registry = registry
        self._loader = loader
        self._basic_key = registry.get("basic-key")
        self._identifier = registry.get("identifier")
        self._cdata = None
        self._locator = None
        self._prefixes = []
        self._schema = None
        self._stack = []
        self._group = None
        self._url = url

    # SAX 2 ContentHandler methods

    def setDocumentLocator(self, locator):
        self._locator = locator

    def startElement(self, name, attrs):
        attrs = dict(attrs)
        if name == "schema":
            if self._schema is not None:
                self.error("schema element improperly nested")
            self.start_schema(attrs)
        elif name in self._handled_tags:
            if self._schema is None:
                self.error(name + " element outside of schema")
            getattr(self, "start_" + name)(attrs)
        elif name in self._cdata_tags:
            if self._schema is None:
                self.error(name + " element outside of schema")
            if self._cdata is not None:
                self.error(name + " element improperly nested")
            self._cdata = []
        else:
            self.error("Unknown tag " + name)

    def characters(self, data):
        if self._cdata is not None:
            self._cdata.append(data)
        elif data.strip():
            self.error("unexpected non-blank character data: "
                       + `data.strip()`)

    def endElement(self, name):
        if name in self._handled_tags:
            getattr(self, "end_" + name)()
        else:
            data = ''.join(self._cdata).strip()
            self._cdata = None
            if name == "default":
                # value for a key
                self._stack[-1].adddefault(data)
            else:
                setattr(self._stack[-1], name, data)

    def endDocument(self):
        if self._schema is None:
            self.error("no schema found")

    # schema loading logic

    def start_import(self, attrs):
        src = attrs.get("src", "").strip()
        if not src:
            self.error("import src may not be omitted or empty")
        src = url.urljoin(self._url, src)
        src, fragment = url.urldefrag(src)
        if fragment:
            self.error("import src many not include a fragment identifier")
        schema = self._loader.loadURL(src)
        for n in schema.gettypenames():
            self._schema.addtype(schema.gettype(n))

    def end_import(self):
        pass

    def get_handler(self, attrs):
        v = attrs.get("handler")
        if v is None:
            return v
        else:
            return self.basic_key(v)

    def push_prefix(self, attrs):
        name = attrs.get("prefix")
        if name:
            if name.startswith(".") and self._prefixes:
                prefix = self._prefixes[-1] + name
            elif name.startswith("."):
                self.error("prefix may not begin with '.'")
            else:
                prefix = name
        elif self._prefixes:
            prefix = self._prefixes[-1]
        else:
            prefix = ''
        self._prefixes.append(prefix)

    def get_classname(self, name):
        if name.startswith("."):
            return self._prefixes[-1] + name
        else:
            return name

    def get_datatype(self, attrs, attrkey, default):
        if attrs.has_key(attrkey):
            dtname = self.get_classname(attrs[attrkey])
        else:
            dtname = default

        try:
            return self._registry.get(dtname)
        except ValueError, e:
            self.error(e[0])

    def get_sect_typeinfo(self, attrs):
        keytype = self.get_datatype(attrs, "keytype", "basic-key")
        valuetype = self.get_datatype(attrs, "valuetype", "string")
        datatype = self.get_datatype(attrs, "datatype", "null")
        return keytype, valuetype, datatype

    def start_schema(self, attrs):
        self.push_prefix(attrs)
        handler = self.get_handler(attrs)
        keytype, valuetype, datatype = self.get_sect_typeinfo(attrs)
        name = attrs.get("type")
        if name is not None:
            name = self.basic_key(name)
        self._schema = info.SchemaType(name, keytype, valuetype, datatype,
                                       handler, self._url)
        if name is not None:
            # XXX circular reference
            self._schema.addtype(self._schema)
        self._schema.registry = self._registry
        self._stack = [self._schema]

    def end_schema(self):
        del self._prefixes[-1]
        assert not self._prefixes

    def start_sectiontype(self, attrs):
        name = attrs.get("type")
        if not name:
            self.error("sectiontype type must not be omitted or empty")
        name = self.basic_key(name)
        self.push_prefix(attrs)
        keytype, valuetype, datatype = self.get_sect_typeinfo(attrs)
        sectinfo = info.SectionType(name, keytype, valuetype, datatype)
        self._schema.addtype(sectinfo)
        if self._group is not None:
            self._group.addtype(sectinfo)
        self._stack.append(sectinfo)

    def end_sectiontype(self):
        del self._prefixes[-1]
        self._stack.pop()

    def get_required(self, attrs):
        if attrs.has_key("required"):
            v = attrs["required"]
            if v == "yes":
                return True
            elif v == "no":
                return False
            self.error("value for 'required' must be 'yes' or 'no'")
        else:
            return False

    def get_ordinality(self, attrs):
        min, max = 0, info.Unbounded
        if self.get_required(attrs):
            min = 1
        return min, max

    def get_sectiontype(self, attrs):
        type = attrs.get("type")
        if not type:
            self.error("section must specify type")
        return self._schema.gettype(type)

    def start_section(self, attrs):
        sectiontype = self.get_sectiontype(attrs)
        handler = self.get_handler(attrs)
        min = self.get_required(attrs) and 1 or 0
        any, name, attribute = self.get_name_info(attrs, "section")
        if any and not attribute:
            self.error(
                "attribute must be specified if section name is '*' or '+'")
        section = info.SectionInfo(any or name, sectiontype,
                                   min, 1, handler, attribute)
        self._stack[-1].addsection(name, section)
        self._stack.append(section)

    def end_section(self):
        self._stack.pop()

    def start_multisection(self, attrs):
        sectiontype = self.get_sectiontype(attrs)
        min, max = self.get_ordinality(attrs)
        any, name, attribute = self.get_name_info(attrs, "multisection")
        if any not in ("*", "+"):
            self.error("multisection must specify '*' or '+' for the name")
        handler = self.get_handler(attrs)
        section = info.SectionInfo(any or name, sectiontype,
                                   min, max, handler, attribute)
        self._stack[-1].addsection(name, section)
        self._stack.append(section)

    def end_multisection(self):
        self._stack.pop()

    def start_sectiongroup(self, attrs):
        if self._group is not None:
            self.error("sectiongroup elements cannot be nested")
        self.push_prefix(attrs)
        name = attrs.get("type")
        if not name:
            self.error("sectiongroup must be named")
        self._group = info.GroupType(name)
        self._schema.addtype(self._group)
        self._stack.append(self._group)

    def end_sectiongroup(self):
        del self._prefixes[-1]
        self._group = None
        self._stack.pop().finish()

    def get_key_info(self, attrs, element):
        any, name, attribute = self.get_name_info(attrs, element)
        if any == '*':
            self.error(element + " may not specify '*' for name")
        if not name and any != '+':
            self.error(element + " name may not be omitted or empty")
        datatype = self.get_datatype(attrs, "datatype", "string")
        handler = self.get_handler(attrs)
        return name or any, datatype, handler, attribute

    def start_key(self, attrs):
        name, datatype, handler, attribute = self.get_key_info(attrs, "key")
        min = self.get_required(attrs) and 1 or 0
        key = info.KeyInfo(name, datatype, min, 1, handler, attribute)
        if attrs.has_key("default"):
            if min:
                self.error("required key cannot have a default value")
            key.adddefault(str(attrs["default"]).strip())
        key.finish()
        self._stack[-1].addkey(key)
        self._stack.append(key)

    def end_key(self):
        self._stack.pop()

    def start_multikey(self, attrs):
        if attrs.has_key("default"):
            self.error("default values for multikey must be given using"
                       " 'default' elements")
        name, datatype, handler, attribute = self.get_key_info(attrs,
                                                               "multikey")
        min, max = self.get_ordinality(attrs)
        key = info.KeyInfo(name, datatype, min, max, handler, attribute)
        self._stack[-1].addkey(key)
        self._stack.append(key)

    def end_multikey(self):
        self._stack.pop().finish()

    def get_name_info(self, attrs, element):
        name = attrs.get("name")
        if not name:
            self.error(element + " name must be specified and non-empty")
        aname = attrs.get("attribute")
        if aname:
            aname = self.identifier(aname)
            if aname.startswith("getSection"):
                # reserved; used for SectionValue methods to get meta-info
                self.error("attribute names may not start with 'getSection'")
        if name in ("*", "+"):
            if not aname:
                self.error(
                    "container attribute must be specified and non-empty"
                    " when using '*' or '+' for a section name")
            return name, None, aname
        else:
            # run the keytype converter to make sure this is a valid key
            name = self._stack[-1].keytype(name)
            if not aname:
                aname = self.basic_key(name)
                aname = self.identifier(aname.replace('-', '_'))
            return None, self.basic_key(name), aname

    # datatype conversion wrappers

    def basic_key(self, s):
        try:
            return self._basic_key(s)
        except ValueError, e:
            self.error(e[0])
        except ZConfig.SchemaError, e:
            self.initerror(e)
            raise

    def identifier(self, s):
        try:
            return self._identifier(s)
        except ValueError, e:
            self.error(e[0])
        except ZConfig.SchemaError, e:
            self.initerror(e)
            raise

    # exception setup helpers

    def initerror(self, e):
        if self._locator is not None:
            e.colno = self._locator.getColumnNumber()
            e.lineno = self._locator.getLineNumber()
            e.url = self._locator.getSystemId()
        return e

    def error(self, message):
        raise self.initerror(ZConfig.SchemaError(message))


=== Added File Zope/lib/python/ZConfig/substitution.py ===
##############################################################################
#
# Copyright (c) 2002 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""Substitution support for ZConfig values."""

import ZConfig

try:
    True
except NameError:
    True = 1
    False = 0


def substitute(s, mapping):
    """Interpolate variables from `section` into `s`."""
    if "$" in s:
        result = ''
        rest = s
        while rest:
            p, name, rest = _split(rest)
            result += p
            if name:
                v = mapping.get(name)
                if v is None:
                    raise ZConfig.SubstitutionReplacementError(s, name)
                result += v
        return result
    else:
        return s


def isname(s):
    """Return True iff s is a valid substitution name."""
    m = _name_match(s)
    if m:
        return m.group() == s
    else:
        return False


def _split(s):
    # Return a triple:  prefix, name, suffix
    # - prefix is text that can be used literally in the result (may be '')
    # - name is a referenced name, or None
    # - suffix is trailling text that may contain additional references
    #   (may be '' or None)
    if "$" in s:
        i = s.find("$")
        c = s[i+1:i+2]
        if c == "":
            raise ZConfig.SubstitutionSyntaxError(
                "illegal lone '$' at end of source")
        if c == "$":
            return s[:i+1], None, s[i+2:]
        prefix = s[:i]
        if c == "{":
            m = _name_match(s, i + 2)
            if not m:
                raise ZConfig.SubstitutionSyntaxError(
                    "'${' not followed by name")
            name = m.group(0)
            i = m.end() + 1
            if not s.startswith("}", i - 1):
                raise ZConfig.SubstitutionSyntaxError(
                    "'${%s' not followed by '}'" % name)
        else:
            m = _name_match(s, i+1)
            if not m:
                raise ZConfig.SubstitutionSyntaxError(
                    "'$' not followed by '$' or name")
            name = m.group(0)
            i = m.end()
        return prefix, name.lower(), s[i:]
    else:
        return s, None, None


import re
_name_match = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*").match
del re


=== Added File Zope/lib/python/ZConfig/url.py ===
"""urlparse-like helpers that support the zconfig scheme."""

import posixpath as _posixpath
import urlparse as _urlparse

from urllib import splittype as _splittype


def urlnormalize(url):
    parts = urlsplit(url)
    if not parts[0]:
        raise ValueError("invalid URL, or file does not exist:\n"
                         + repr(url))
    url = urlunsplit(parts)
    if url.startswith("file:/") and not url.startswith("file:///"):
        url = "file://" + url[5:]
    return url


def urlunsplit(parts):
    url = _urlparse.urlunsplit(parts)
    if (  parts[0] == "file"
          and url.startswith("file:/")
          and not url.startswith("file:///")):
        url = "file://" + url[5:]
    return url


def urldefrag(url):
    parts = urlsplit(url)
    if parts[0] == "zconfig":
        return "zconfig:" + parts[2], parts[4]
    else:
        url, fragment = _urlparse.urldefrag(url)
        return urlnormalize(url), fragment


def urljoin(base, relurl):
    scheme = _splittype(base)[0]
    if scheme != "zconfig":
        url = _urlparse.urljoin(base, relurl)
        if url.startswith("file:/") and not url.startswith("file:///"):
            url = "file://" + url[5:]
        return url
    relscheme = _splittype(relurl)[0]
    if relscheme and relscheme != "zconfig":
        return _urlparse.urljoin(base, relurl)
    baseparts = urlsplit(base)
    relparts = urlsplit(relurl, "zconfig")
    if relparts[2]:
        d = _posixpath.dirname(baseparts[2])
        if d:
            d += "/"
        path = _posixpath.normpath(_posixpath.join(d, relparts[2]))
    else:
        path = baseparts[2]
    parts = path.split('/')
    if '..' in parts:
        raise ValueError("zconfig URIs cannot include '..' references: "
                         + `path`)
    s = "zconfig:" + path
    if relparts[4]:
        s += "#" + relparts[4]
    return s


def urlsplit(url, scheme=''):
    stated_scheme = _splittype(url)[0]
    scheme = stated_scheme or scheme
    parts = _urlparse.urlsplit(url, scheme=scheme)
    if scheme == "zconfig":
        path = parts[2]
        if stated_scheme:
            # These constraints only apply to absolute zconfig: URLs
            if not path:
                # Require a non-empty path; empty path is ok for
                # relative URL ("#frag").
                raise ValueError(
                    "zconfig URIs require a non-empty path component")
            if '..' in path.split('/'):
                raise ValueError(
                    "zconfig URIs cannot include '..' references: " + `url`)
        # Split the fragment ourselves since the urlparse module
        # doesn't know about the zconfig: scheme.
        if '#' in path:
            path, fragment = path.split('#', 1)
            parts = "zconfig", '', path, '', fragment
        if path[:1] == '/':
            raise ValueError(
                "path component of zconfig: URIs may not start with '/'")
        if '?' in path:
            raise ValueError("zconfig: URIs may not contain queries: "
                             + `url`)
    return parts


=== Zope/lib/python/ZConfig/BRANCHES.txt 1.1.4.1 => 1.1.4.2 ===
--- Zope/lib/python/ZConfig/BRANCHES.txt:1.1.4.1	Thu Oct 10 14:29:12 2002
+++ Zope/lib/python/ZConfig/BRANCHES.txt	Fri Jan  3 10:51:55 2003
@@ -6,3 +6,9 @@
     An example of an alternate syntax for ZConfig.  This syntax was
     developed while trying the package initially, but was rejected.
     It is saved on a branch to avoid losing historical information.
+
+zconfig-schema-devel-branch
+    Development branch for schema support in ZConfig.  The branch is
+    based on the ZConfig trunk, but the development is strongly based
+    on the work Chris McDonough started in the chrism-install-branch
+    for Zope 2.


=== Zope/lib/python/ZConfig/Config.py 1.2.4.6 => 1.2.4.7 ===
--- Zope/lib/python/ZConfig/Config.py:1.2.4.6	Fri Dec  6 11:06:23 2002
+++ Zope/lib/python/ZConfig/Config.py	Fri Jan  3 10:51:55 2003
@@ -1,12 +1,22 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
 """Configuration data structure."""
 
 import ZConfig
 
-try:
-    True
-except NameError:
-    True = 1
-    False = 0
+from ZConfig.datatypes import asBoolean
+
 
 class Configuration:
     def __init__(self, container, type, name, url):
@@ -103,21 +113,10 @@
 
     def has_key(self, key):
         key = key.lower()
-        if self._data.has_key(key):
-            return True
-        elif self.delegate:
-            return self.delegate.has_key(key)
-        else:
-            return False
-
-    def has_key(self, key):
-        key = key.lower()
-        if self._data.has_key(key):
-            return True
-        elif self.delegate:
-            return self.delegate.has_key(key)
-        else:
-            return False
+        have = self._data.has_key(key)
+        if self.delegate and not have:
+            have = self.delegate.has_key(key)
+        return have
 
     def items(self):
         """Returns a list of key-value pairs for this section.
@@ -199,32 +198,3 @@
             return default
         else:
             return s.split()
-
-
-class ImportingConfiguration(Configuration):
-    def __init__(self, url):
-        self._imports = []
-        Configuration.__init__(self, None, None, None, url)
-
-    def addImport(self, section):
-        self._imports.append(section)
-
-    def get(self, key, default=None):
-        s = Configuration.get(self, key, default)
-        if s is default:
-            for config in self._imports:
-                s = config.get(key, default)
-                if s is not default:
-                    break
-        return s
-
-
-def asBoolean(s):
-    """Convert a string value to a boolean value."""
-    ss = str(s).lower()
-    if ss in ('yes', 'true', 'on'):
-        return True
-    elif ss in ('no', 'false', 'off'):
-        return False
-    else:
-        raise ValueError("not a valid boolean value: " + repr(s))


=== Zope/lib/python/ZConfig/Context.py 1.1.4.6 => 1.1.4.7 ===
--- Zope/lib/python/ZConfig/Context.py:1.1.4.6	Fri Dec  6 11:06:23 2002
+++ Zope/lib/python/ZConfig/Context.py	Fri Jan  3 10:51:55 2003
@@ -1,40 +1,41 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
 """Top-level configuration handle."""
 
-import os
-import urllib
-import urllib2
 import urlparse
 
 import ZConfig
 
-from Config import Configuration, ImportingConfiguration
-from Substitution import isname, substitute
+from ZConfig import loader
+from ZConfig.Config import Configuration
 
 
-class Context:
+class Context(loader.BaseLoader):
 
     def __init__(self):
-        self._imports = []         # URL  -> Configuration
+        loader.BaseLoader.__init__(self)
         self._named_sections = {}  # name -> Configuration
         self._needed_names = {}    # name -> [needy Configuration, ...]
-        self._current_imports = []
         self._all_sections = []
 
     # subclass-support API
 
-    def createImportedSection(self, section, url):
-        return ImportingConfiguration(url)
-
     def createNestedSection(self, section, type, name, delegatename):
-        if name:
-            name = name.lower()
-        return Configuration(section, type.lower(), name, section.url)
+        return Configuration(section, type, name, section.url)
 
     def createToplevelSection(self, url):
-        return ImportingConfiguration(url)
-
-    def createResource(self, file, url):
-        return Resource(file, url)
+        return Configuration(None, None, None, url)
 
     def getDelegateType(self, type):
         # Applications must provide delegation typing information by
@@ -42,74 +43,27 @@
         return type.lower()
 
     def parse(self, resource, section):
-        from ApacheStyle import Parse
-        Parse(resource, self, section)
-
-    def _normalize_url(self, url):
-        if os.path.exists(url):
-            url = "file://" + urllib.pathname2url(os.path.abspath(url))
-        else:
-            parts = urlparse.urlparse(url)
-            if not parts[0]:
-                raise ValueError("invalid URL, or file does not exist:\n"
-                                 + repr(url))
-        return url
-
-    # public API
-
-    def load(self, url):
-        """Load a resource from a URL or pathname."""
-        url = self._normalize_url(url)
-        top = self.createToplevelSection(url)
-        self._all_sections.append(top)
-        self._imports = [top]
-        self._parse_url(url, top)
-        self._finish()
-        return top
+        from ZConfig.cfgparser import ZConfigParser
+        ZConfigParser(resource, self).parse(section)
 
-    def loadfile(self, file, url=None):
-        if not url:
-            name = getattr(file, "name", None)
-            if name and name[0] != "<" and name[-1] != ">":
-                url = "file://" + urllib.pathname2url(os.path.abspath(name))
-        top = self.createToplevelSection(url)
+    def loadResource(self, resource):
+        top = self.createToplevelSection(resource.url)
         self._all_sections.append(top)
-        self._imports = [top]
-        self._current_imports.append(top)
-        r = self.createResource(file, url)
-        try:
-            self.parse(r, top)
-        finally:
-            del self._current_imports[-1]
+        self.parse(resource, top)
         self._finish()
         return top
 
 
     # interface for parser
 
-    def importConfiguration(self, section, url):
-        for config in self._imports:
-            if config.url == url:
-                return config
-        newsect = self.createImportedSection(section, url)
-        self._all_sections.append(newsect)
-        self._imports.append(newsect)
-        section.addImport(newsect)
-        self._parse_url(url, newsect)
-
     def includeConfiguration(self, section, url):
-        # XXX we always re-parse, unlike import
-        file = urllib2.urlopen(url)
-        r = self.createResource(file, url)
+        r = self.openResource(url)
         try:
             self.parse(r, section)
         finally:
-            file.close()
+            r.close()
 
-    def nestSection(self, section, type, name, delegatename):
-        if name:
-            name = name.lower()
-        type = type.lower()
+    def startSection(self, section, type, name, delegatename):
         if name and self._named_sections.has_key(name):
             # Make sure sections of the same name are not defined
             # twice in the same resource, and that once a name has
@@ -135,30 +89,12 @@
         section.addChildSection(newsect)
         if name:
             self._named_sections[name] = newsect
-            current = self._current_imports[-1]
-            if section is not current:
-                current.addNamedSection(newsect)
-            for config in self._current_imports[:-1]:
-                # XXX seems very painful
-                if not config._sections_by_name.has_key((type, name)):
-                    config.addNamedSection(newsect)
         return newsect
 
-    # internal helpers
+    def endSection(self, parent, type, name, delegatename, section):
+        section.finish()
 
-    def _parse_url(self, url, section):
-        url, fragment = urlparse.urldefrag(url)
-        if fragment:
-            raise ZConfig.ConfigurationError(
-                "fragment identifiers are not currently supported")
-        file = urllib2.urlopen(url)
-        self._current_imports.append(section)
-        r = self.createResource(file, url)
-        try:
-            self.parse(r, section)
-        finally:
-            del self._current_imports[-1]
-            file.close()
+    # internal helpers
 
     def _finish(self):
         # Resolve section delegations
@@ -195,24 +131,3 @@
             if sect.delegate is not None:
                 sect.finish()
         self._all_sections = None
-
-
-class Resource:
-    def __init__(self, file, url):
-        self.file = file
-        self.url = url
-        self._definitions = {}
-
-    def define(self, name, value):
-        key = name.lower()
-        if self._definitions.has_key(key):
-            raise ZConfig.ConfigurationError("cannot redefine " + `name`)
-        if not isname(name):
-            raise ZConfig.ConfigurationError(
-                "not a substitution legal name: " + `name`)
-        self._definitions[key] = value
-
-    def substitute(self, s):
-        # XXX  I don't really like calling this substitute(),
-        # XXX  but it will do for now.
-        return substitute(s, self._definitions)


=== Zope/lib/python/ZConfig/__init__.py 1.1.4.8 => 1.1.4.9 ===
--- Zope/lib/python/ZConfig/__init__.py:1.1.4.8	Fri Dec  6 11:06:23 2002
+++ Zope/lib/python/ZConfig/__init__.py	Fri Jan  3 10:51:55 2003
@@ -16,20 +16,100 @@
 $Id$
 """
 
-from ZConfig.Exceptions import *
+from ZConfig.loader import loadConfig, loadConfigFile
+from ZConfig.loader import loadSchema, loadSchemaFile
 
-def load(url):
+
+def loadURL(url):
     import Context
-    return Context.Context().load(url)
+    return Context.Context().loadURL(url)
 
-def loadfile(file, url=None):
+def loadFile(file, url=None):
     import Context
-    return Context.Context().loadfile(file, url)
+    return Context.Context().loadFile(file, url)
+
+
+class ConfigurationError(Exception):
+    def __init__(self, msg):
+        self.message = msg
+        Exception.__init__(self, msg)
+
+    def __str__(self):
+        return self.message
+
+
+class _ParseError(ConfigurationError):
+    def __init__(self, msg, url, lineno, colno=None):
+        self.url = url
+        self.lineno = lineno
+        self.colno = colno
+        ConfigurationError.__init__(self, msg)
+
+    def __str__(self):
+        s = self.message
+        if self.url:
+            s += "\n("
+        elif (self.lineno, self.colno) != (None, None):
+            s += " ("
+        if self.lineno:
+            s += "line %d" % self.lineno
+            if self.colno is not None:
+                s += ", column %d" % self.colno
+            if self.url:
+                s += " in %s)" % self.url
+            else:
+                s += ")"
+        elif self.url:
+            s += self.url + ")"
+        return s
+
+
+class SchemaError(_ParseError):
+    """Raised when there's an error in the schema itself."""
+
+    def __init__(self, msg, url=None, lineno=None, colno=None):
+        _ParseError.__init__(self, msg, url, lineno, colno)
+
+
+class ConfigurationMissingSectionError(ConfigurationError):
+    def __init__(self, type, name=None):
+        self.type = type
+        self.name = name
+        details = 'Missing section (type: %s' % type
+        if name is not None:
+            details += ', name: %s' % name
+        ConfigurationError.__init__(self, details + ')')
+
+
+class ConfigurationConflictingSectionError(ConfigurationError):
+    def __init__(self, type, name=None):
+        self.type = type
+        self.name = name
+        details = 'Conflicting sections (type: %s' % type
+        if name is not None:
+            details += ', name: %s' % name
+        ConfigurationError.__init__(self, details + ')')
+
+
+class ConfigurationSyntaxError(_ParseError):
+    """Raised when there's a syntax error in a configuration file."""
+
+
+class ConfigurationTypeError(ConfigurationError):
+    def __init__(self, msg, found, expected):
+        self.found = found
+        self.expected = expected
+        ConfigurationError.__init__(self, msg)
+
+
+class SubstitutionSyntaxError(ConfigurationError):
+    """Raised when interpolation source text contains syntactical errors."""
+
+
+class SubstitutionReplacementError(ConfigurationError, LookupError):
+    """Raised when no replacement is available for a reference."""
 
-def loadschema(url, schema):
-    from SchemaParser import SchemaContext
-    return SchemaContext().load(url, schema)
-
-def loadschemafile(file, schema, url=None):
-    from SchemaParser import SchemaContext
-    return SchemaContext().load(file, url, schema)
+    def __init__(self, source, name):
+        self.source = source
+        self.name = name
+        ConfigurationError.__init__(self, "no replacement for " + `name`)