# XML "function" nodes that transform their contents

            +exc.str_(cause))

funcs = {}

def process(node, on_error=exc.raise_):

    for child in xml_dom.NodeElemIter(node): process(child, on_error)

    name = node.tagName

    if name.startswith('_') and name in funcs:

        try: value = funcs[name](xml_dom.NodeTextEntryIter(node))

        except SyntaxException, e:

            str_ = str(node)

            exc.add_msg(e, 'function:\n'+str_)

            xml_dom.replace(node, node.ownerDocument.createComment(

                # comments can't contain '--'

        else: xml_dom.replace_with_text(node, value)

    return [(name, func(value)) for name, value in items]

    '''Throws SyntaxException if can't cast'''

    try: return type_(val)

    except ValueError, e: raise SyntaxException(e)

        xml_dom.TextEntryOnlyIter(items))

# Function names must start with _ to avoid collisions with real tags

# Functions take arguments (items)

def _ignore(items):

    return None

    items = dict(items)

    try:

        left = items['left']

        right = items['right']

    except KeyError: return '' # a value was None

    return util.bool2str(left == right)

funcs['_eq'] = _eq

def _if(items):

    items = dict(items)

    try:

        cond = items['cond']

        then = items['then']

    except KeyError, e: raise SyntaxException(e)

    else_ = items.get('else', None)

    cond = bool(cast(str, cond))

    if cond: return then

    else: return else_

funcs['_if'] = _if

    items.sort()

        # get *once* from iter and check types

    return maps.merge_values(*[v for k, v in items])

    try:

        label = items['label']

        value = items['value']

    except KeyError, e: raise SyntaxException(e)

    return label+': '+value

    items = dict(conv_items(str, items))

    try:

        null = items['null']

        value = items['value']

    except KeyError, e: raise SyntaxException(e)

    type_ = str

    if type_str == 'float': type_ = float

    return util.none_if(value, type_(null))

    items = conv_items(str, items) # get *once* from iter and check types

    try: value = items.pop()[1] # value is last entry's value

    except IndexError, e: raise SyntaxException(e)

    map_ = dict(items)

        if closed: raise SyntaxException(e)

        else: return value

def _replace(items):

    items = conv_items(str, items) # get *once* from iter and check types

    try: value = items.pop() # value is last entry

    except IndexError, e: raise SyntaxException(e)

    try:

        for repl, with_ in items:

            if re.match(r'^\w+$', repl):

                repl = r'(?<![^\W_])'+repl+r'(?![^\W_])' # match whole word

            value = re.sub(repl, with_, value)

    except sre_constants.error, e: raise SyntaxException(e)

    return value

funcs['_replace'] = _replace

    items = dict(conv_items(str, items))

    try:

        units = items['units']

        value = items['value']

    except KeyError, e: raise SyntaxException(e)

    return value#+' '+units # don't add yet because unit conversion isn't ready

funcs['_units'] = _units

    to = items.get('to', None)

    if from_ == None or to == None: return None

    sum_ = 0.

        sum_ += value

    return str(sum_/count)

    def __init__(self):

        Exception.__init__(self, 'CV (coefficient of variation) values are only'

            ' allowed for ratio scale data '

            '(see <http://en.wikipedia.org/wiki/Coefficient_of_variation>)')

    except StopIteration: return None

    if re.match('^(?i)CV *\d+$', value): raise SyntaxException(CvException())

    return value

    except KeyError:

            if items == {}: return None # entire date is empty

            else: raise SyntaxException(e)

        items.setdefault('day', 1)

        try: date = datetime.date(**items)

        except ValueError, e: raise SyntaxException(e)

    else:

        except ValueError:

            except ValueError, e: raise SyntaxException(e)

        else: date = (datetime.date(int(year), 1, 1) +

            datetime.timedelta(round((year % 1.)*365)))

date_range_date_part_sep = ' '

def _dateRangePart(items):

    items = dict(conv_items(str, items))

    try:

        part = items['part']

        value = items['value']

    except KeyError, e: raise SyntaxException(e)

    value = value.strip()

    if value.find(date_range_date_part_sep) < 0: return value

        # date_range_sep might be used as date part separator instead

    start, sep, end = value.partition(date_range_sep)

    if sep == '': return value # not a range

    start = start.split(date_range_date_part_sep)

    end = end.split(date_range_date_part_sep)

    #if len(end) < 3

    #if len(start) < len(end): # range

funcs['_dateRangePart'] = _dateRangePart

    ('first', slice(None, 1)),

    ('middle', slice(1, -1)),

    ('last', slice(-1, None)),

]

name_parts_slices = dict(_name_parts_slices_items)

name_parts = [name for name, slice_ in _name_parts_slices_items]

        if part in items: parts.append(items[part])

    for part, value in items:

        try: slice_ = name_parts_slices[part]

        except KeyError, e: raise SyntaxException(e)

funcs['_namePart'] = _namePart

def _simplifyPath(items):

    items = dict(items)

    try:

        next = cast(str, items['next'])

        require = cast(str, items['require'])

        root = items['path']

    except KeyError, e: raise SyntaxException(e)

    node = root

    while node != None:

        new_node = xpath.get_1(node, next, allow_rooted=False)

        if xpath.get_1(node, require, allow_rooted=False) == None: # empty elem

            xml_dom.replace(node, new_node) # remove current elem

            if node is root: root = new_node # also update root

        node = new_node

    return root

funcs['_simplifyPath'] = _simplifyPath