"""
svdpatch.py

Copyright 2017-2019 Adam Greig.
Licensed under the MIT and Apache 2.0 licenses. See LICENSE files for details.

This script was adapted from stm32-rs (https://github.com/stm32-rs/stm32-rs/blob/master/scripts/svdpatch.py).
To be integrated into the build system, support for an input / output svd argument is added.

Additional changes:
    - Support for _replace_enum to overwrite existing <enumeratedValues>
    - Fix field modifications not being able to add new elements
    - Add _write_constraint modifier for changing the <writeConstraint>
    - Fix peripheral modifications not being able to add new elements
"""

import copy
import yaml
import os.path
import argparse
import xml.etree.ElementTree as ET
from fnmatch import fnmatch
from collections import OrderedDict


DEVICE_CHILDREN = [
    "vendor", "vendorID", "name", "series", "version", "description",
    "licenseText", "headerSystemFilename", "headerDefinitionsPrefix",
    "addressUnitBits", "width", "size", "access", "protection", "resetValue",
    "resetMask"]


# Set up pyyaml to use ordered dicts so we generate the same
# XML output each time
def dict_constructor(loader, node):
    return OrderedDict(loader.construct_pairs(node))


_mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
yaml.add_constructor(_mapping_tag, dict_constructor, yaml.SafeLoader)


def parseargs():
    """Parse our command line arguments, returns a Namespace of results."""
    parser = argparse.ArgumentParser()
    parser.add_argument("yaml", help="Path to YAML file to load")
    parser.add_argument("svd_in", help="Path to the input SVD file")
    parser.add_argument("svd_out", help="Path to write the patched SVD file")
    args = parser.parse_args()
    return args


def matchname(name, spec):
    """Check if name matches against a specification."""
    return (
        (not spec.startswith("_"))
        and any(fnmatch(name, subspec) for subspec in spec.split(",")))


def abspath(frompath, relpath):
    """Gets the absolute path of relpath from the point of view of frompath."""
    basepath = os.path.realpath(
        os.path.join(os.path.abspath(frompath), os.pardir))
    return os.path.normpath(os.path.join(basepath, relpath))


def update_dict(parent, child):
    """
    Recursively merge child.key into parent.key, with parent overriding.
    """
    for key in child:
        if key == "_path" or key == "_include":
            continue
        elif key in parent:
            if isinstance(parent[key], list):
                parent[key] += child[key]
            elif isinstance(parent[key], dict):
                update_dict(parent[key], child[key])
        else:
            parent[key] = child[key]


def yaml_includes(parent):
    """Recursively loads any included YAML files."""
    included = []
    for relpath in parent.get("_include", []):
        path = abspath(parent["_path"], relpath)
        if path in included:
            continue
        with open(path) as f:
            child = yaml.safe_load(f)
        child["_path"] = path
        included.append(path)
        # Process any peripheral-level includes in child
        for pspec in child:
            if not pspec.startswith("_") and "_include" in child[pspec]:
                child[pspec]["_path"] = path
                included += yaml_includes(child[pspec])
        # Process any top-level includes in child
        included += yaml_includes(child)
        update_dict(parent, child)
    return included


def make_write_constraint(wc_range):
    """Given a (min, max), returns a writeConstraint Element."""
    wc = ET.Element('writeConstraint')
    r = ET.SubElement(wc, 'range')
    minimum = ET.SubElement(r, 'minimum')
    minimum.text = str(wc_range[0])
    maximum = ET.SubElement(r, 'maximum')
    maximum.text = str(wc_range[1])
    wc.tail = "\n            "
    return wc


def make_enumerated_values(name, values, usage="read-write"):
    """
    Given a name and a dict of values which maps variant names to (value,
    description), returns an enumeratedValues Element.
    """
    ev = ET.Element('enumeratedValues')
    usagekey = {
        "read": "R",
        "write": "W",
    }.get(usage, "")
    ET.SubElement(ev, 'name').text = name + usagekey
    ET.SubElement(ev, 'usage').text = usage
    if len(set(v[0] for v in values.values())) != len(values):
        raise ValueError("enumeratedValue {}: can't have duplicate values"
                         .format(name))
    if name[0] in "0123456789":
        raise ValueError("enumeratedValue {}: can't start with a number"
                         .format(name))
    for vname in values:
        if vname.startswith("_"):
            continue
        if vname[0] in "0123456789":
            raise ValueError("enumeratedValue {}.{}: can't start with a number"
                             .format(name, vname))
        value, description = values[vname]
        if not description:
            raise ValueError("enumeratedValue {}: can't have empty description"
                             " for value {}".format(name, value))
        el = ET.SubElement(ev, 'enumeratedValue')
        ET.SubElement(el, 'name').text = vname
        ET.SubElement(el, 'description').text = description
        ET.SubElement(el, 'value').text = str(value)
    ev.tail = "\n            "
    return ev


def make_derived_enumerated_values(name):
    """Returns an enumeratedValues Element which is derivedFrom name."""
    evd = ET.Element('enumeratedValues', {"derivedFrom": name})
    evd.tail = "\n            "
    return evd


def iter_peripherals(tree, pspec, check_derived=True):
    """Iterates over all peripherals that match pspec."""
    for ptag in tree.iter('peripheral'):
        name = ptag.find('name').text
        if matchname(name, pspec):
            if check_derived and "derivedFrom" in ptag.attrib:
                continue
            yield ptag


def iter_registers(ptag, rspec):
    """
    Iterates over all registers that match rspec and live inside ptag.
    """
    for rtag in ptag.iter('register'):
        name = rtag.find('name').text
        if matchname(name, rspec):
            yield rtag


def iter_fields(rtag, fspec):
    """
    Iterates over all fields that match fspec and live inside rtag.
    """
    for ftag in rtag.find('fields').iter('field'):
        name = ftag.find('name').text
        if matchname(name, fspec):
            yield ftag


def process_device_peripheral_modify(device, pspec, pmod):
    """Modify pspec inside device according to pmod."""
    for ptag in iter_peripherals(device, pspec):
        for (key, value) in pmod.items():
            ptag.find(key).text = str(value)


def process_device_child_modify(device, key, val):
    """Modify key inside device and set it to val."""
    for child in device.findall(key):
        child.text = str(val)


def process_device_cpu_modify(device, mod):
    """Modify the `cpu` node inside `device` according to `mod`."""
    cpu = device.find('cpu')
    for key, val in mod.items():
        field = cpu.find(key)
        if field is not None:
            field.text = str(val)
        else:
            field = ET.SubElement(cpu, key)
            field.text = str(val)


def process_peripheral_modify(ptag, rspec, rmod):
    """Modify rspec inside ptag according to rmod."""
    for rtag in iter_registers(ptag, rspec):
        for (key, value) in rmod.items():
            field = rtag.find(key)
            if field is not None:
                field.text = value
            else:
                field = ET.SubElement(rtag, key)
                field.text = value


def process_register_modify(rtag, fspec, fmod):
    """Modify fspec inside rtag according to fmod."""
    for ftag in iter_fields(rtag, fspec):
        for (key, value) in fmod.items():
            if key == "_write_constraint":
                key = "writeConstraint"

            tag = ftag.find(key)
            if tag is None:
                tag = ET.SubElement(ftag, key)

            if key == "writeConstraint":
                # Remove existing constraint contents
                for child in list(tag):
                    tag.remove(child)
                if value == "none":
                    # Completely remove the existing writeConstraint
                    ftag.remove(tag)
                elif value == "enum":
                    # Only allow enumerated values
                    enum_tag = ET.SubElement(tag, "useEnumeratedValues")
                    enum_tag.text = "true"
                elif isinstance(value, list):
                    # Allow a certain range
                    range_tag = make_write_constraint(value).find("range")
                    tag.append(range_tag)
                else:
                    raise SvdPatchError('Unknown writeConstraint type {}'
                                        .format(repr(value)))
            else:
                # For all other tags, just set the value
                tag.text = str(value)


def process_device_add(device, pname, padd):
    """Add pname given by padd to device."""
    parent = device.find('peripherals')
    for ptag in parent.iter('peripheral'):
        if ptag.find('name').text == pname:
            raise SvdPatchError('device already has a peripheral {}'
                                .format(pname))
    if "derivedFrom" in padd:
        derived = padd["derivedFrom"]
        pnew = ET.SubElement(parent, 'peripheral', {"derivedFrom": derived})
    else:
        pnew = ET.SubElement(parent, 'peripheral')
    ET.SubElement(pnew, 'name').text = pname
    for (key, value) in padd.items():
        if key == "registers":
            ET.SubElement(pnew, 'registers')
            for rname in value:
                process_peripheral_add_reg(pnew, rname, value[rname])
        elif key == "interrupts":
            for iname in value:
                process_peripheral_add_int(pnew, iname, value[iname])
        elif key == "addressBlock":
            ab = ET.SubElement(pnew, 'addressBlock')
            for (ab_key, ab_value) in value.items():
                ET.SubElement(ab, ab_key).text = str(ab_value)
        elif key != "derivedFrom":
            ET.SubElement(pnew, key).text = str(value)
    pnew.tail = "\n    "


def process_device_derive(device, pname, pderive):
    """
    Remove registers from pname and mark it as derivedFrom pderive.
    Update all derivedFrom referencing pname.
    """
    parent = device.find('peripherals')
    ptag = parent.find('./peripheral[name=\'{}\']'.format(pname))
    derived = parent.find('./peripheral[name=\'{}\']'.format(pderive))
    if ptag is None:
        raise SvdPatchError('peripheral {} not found'.format(pname))
    if derived is None:
        raise SvdPatchError('peripheral {} not found'.format(pderive))
    for (value) in list(ptag):
        if value.tag in ('name', 'baseAddress', 'interrupt'):
            continue
        ptag.remove(value)
    for value in ptag:
        last = value
    last.tail = "\n    "
    ptag.set('derivedFrom', pderive)
    for p in parent.findall('./peripheral[@derivedFrom=\'{}\']'.format(pname)):
        p.set('derivedFrom', pderive)


def process_device_rebase(device, pnew, pold):
    """
    Move registers from pold to pnew.
    Update all derivedFrom referencing pold.
    """
    parent = device.find('peripherals')
    old = parent.find('./peripheral[name=\'{}\']'.format(pold))
    new = parent.find('./peripheral[name=\'{}\']'.format(pnew))
    if old is None:
        raise SvdPatchError('peripheral {} not found'.format(pold))
    if new is None:
        raise SvdPatchError('peripheral {} not found'.format(pnew))
    for value in new:
        last = value
    last.tail = "\n      "
    for (value) in list(old):
        if value.tag in ('name', 'baseAddress', 'interrupt'):
            continue
        old.remove(value)
        new.append(value)
    for value in old:
        last = value
    last.tail = "\n    "
    del new.attrib['derivedFrom']
    old.set('derivedFrom', pnew)
    for p in parent.findall('./peripheral[@derivedFrom=\'{}\']'.format(pold)):
        p.set('derivedFrom', pnew)


def process_peripheral_add_reg(ptag, rname, radd):
    """Add rname given by radd to ptag."""
    parent = ptag.find('registers')
    for rtag in parent.iter('register'):
        if rtag.find('name').text == rname:
            raise SvdPatchError('peripheral {} already has a register {}'
                                .format(ptag.find('name').text, rname))
    rnew = ET.SubElement(parent, 'register')
    ET.SubElement(rnew, 'name').text = rname
    ET.SubElement(rnew, 'fields')
    for (key, value) in radd.items():
        if key == "fields":
            for fname in value:
                process_register_add(rnew, fname, value[fname])
        else:
            ET.SubElement(rnew, key).text = str(value)
    rnew.tail = "\n        "


def process_peripheral_add_int(ptag, iname, iadd):
    """Add iname given by iadd to ptag."""
    for itag in ptag.iter('interrupt'):
        if itag.find('name').text == iname:
            raise SvdPatchError('peripheral {} already has an interrupt {}'
                                .format(ptag.find('name').text, iname))
    inew = ET.SubElement(ptag, 'interrupt')
    ET.SubElement(inew, 'name').text = iname
    for key, val in iadd.items():
        ET.SubElement(inew, key).text = str(val)
    inew.tail = "\n    "


def process_register_add(rtag, fname, fadd):
    """Add fname given by fadd to rtag."""
    parent = rtag.find('fields')
    if parent is None:
        parent = ET.SubElement(rtag, 'fields')
    else:
        for ftag in parent.iter('field'):
            if ftag.find('name').text == fname:
                raise SvdPatchError('register {} already has a field {}'
                                    .format(rtag.find('name').text, fname))
    fnew = ET.SubElement(parent, 'field')
    ET.SubElement(fnew, 'name').text = fname
    for (key, value) in fadd.items():
        ET.SubElement(fnew, key).text = str(value)
    fnew.tail = "\n            "


def process_device_delete(device, pspec):
    """Delete registers matched by rspec inside ptag."""
    for ptag in list(iter_peripherals(device, pspec, check_derived=False)):
        device.find('peripherals').remove(ptag)


def process_peripheral_delete(ptag, rspec):
    """Delete registers matched by rspec inside ptag."""
    for rtag in list(iter_registers(ptag, rspec)):
        ptag.find('registers').remove(rtag)


def process_register_delete(rtag, fspec):
    """Delete fields matched by fspec inside rtag."""
    for ftag in list(iter_fields(rtag, fspec)):
        rtag.find('fields').remove(ftag)

def process_peripheral_strip(ptag, prefix):
    """Delete prefix in register names inside ptag."""
    for rtag in ptag.iter('register'):
        nametag = rtag.find('name')
        name = nametag.text
        if name.startswith(prefix):
            nametag.text = name[len(prefix):]
            dnametag = rtag.find('displayName')
            dname = dnametag.text
            if dname.startswith(prefix):
                dnametag.text = dname[len(prefix):]

def spec_ind(spec):
    """
    Find left and right indices of enumeration token in specification string.
    """
    li1 = spec.find("*")
    li2 = spec.find("?")
    li3 = spec.find("[")
    li = li1 if li1 > -1 else li2 if li2 > -1 else li3 if li3 > -1 else None
    ri1 = spec[::-1].find("*")
    ri2 = spec[::-1].find("?")
    ri3 = spec[::-1].find("]")
    ri = ri1 if ri1 > -1 else ri2 if ri2 > -1 else ri3 if ri3 > -1 else None
    return li, ri


def check_offsets(offsets, dimIncrement):
    for o1, o2 in zip(offsets[:-1], offsets[1:]):
        if o2-o1 != dimIncrement:
            return False
    return True

def get_bitmask(rtag):
    """Calculate filling of register"""
    mask = 0x0
    for ftag in iter_fields(rtag, "*"):
        foffset = int(ftag.findtext("bitOffset"), 0)
        fwidth = int(ftag.findtext("bitWidth"), 0)
        mask |= (0xffffffff >> (32-fwidth)) << foffset
    return mask

def check_bitmasks(masks, mask):
    for m in masks:
        if m != mask:
            return False
    return True

def process_peripheral_regs_array(ptag, rspec, rmod):
    """Collect same registers in peripheral into register array."""
    registers = []
    li, ri = spec_ind(rspec)
    for rtag in list(iter_registers(ptag, rspec)):
        rname = rtag.findtext('name')
        registers.append([rtag, rname[li:len(rname)-ri],
                          int(rtag.findtext('addressOffset'), 0)])
    dim = len(registers)
    if dim == 0:
        raise SvdPatchError("{}: registers {} not found"
                            .format(ptag.findtext('name'), rspec))
    registers = sorted(registers, key=lambda r: r[2])

    dimIndex = "{0}-{0}".format(registers[0][1]) if dim == 1 else ",".join([r[1] for r in registers])
    offsets = [r[2] for r in registers]
    bitmasks = [get_bitmask(r[0]) for r in registers]
    dimIncrement = 0
    if dim > 1:
        dimIncrement = offsets[1]-offsets[0]

    if not (check_offsets(offsets, dimIncrement) and check_bitmasks(bitmasks, bitmasks[0])):
        raise SvdPatchError("{}: registers cannot be collected into {} array"
                            .format(ptag.findtext('name'), rspec))
    for rtag, _, _ in registers[1:]:
        ptag.find('registers').remove(rtag)
    rtag = registers[0][0]
    if 'name' in rmod:
        name = rmod['name']
    else:
        name = rspec[:li]+"%s"+rspec[len(rspec)-ri:]
    rtag.find('name').text = name
    process_peripheral_register(ptag, name, rmod)
    ET.SubElement(rtag, 'dim').text = str(dim)
    ET.SubElement(rtag, 'dimIndex').text = dimIndex
    ET.SubElement(rtag, 'dimIncrement').text = hex(dimIncrement)


def process_peripheral_cluster(ptag, cname, cmod):
    """Collect registers in peripheral into clusters."""
    rdict = {}
    first = True
    check = True
    rspecs = [r for r in cmod if r != "description"]
    for rspec in rspecs:
        registers = []
        li, ri = spec_ind(rspec)
        for rtag in list(iter_registers(ptag, rspec)):
            rname = rtag.findtext('name')
            registers.append([rtag, rname[li:len(rname)-ri],
                              int(rtag.findtext('addressOffset'), 0)])
        registers = sorted(registers, key=lambda r: r[2])
        rdict[rspec] = registers
        bitmasks = [get_bitmask(r[0]) for r in registers]
        if first:
            dim = len(registers)
            if dim == 0:
                check = False
                break
            dimIndex = ",".join([r[1] for r in registers])
            offsets = [r[2] for r in registers]
            dimIncrement = 0
            if dim > 1:
                dimIncrement = offsets[1]-offsets[0]
            if not (check_offsets(offsets, dimIncrement) and check_bitmasks(bitmasks, bitmasks[0])):
                check = False
                break
        else:
            if (
                    (dim != len(registers)) or
                    (dimIndex != ",".join([r[1] for r in registers])) or
                    (not check_offsets(offsets, dimIncrement)) or
                    (not check_bitmasks(bitmasks, bitmasks[0]))
               ):
                check = False
                break
        first = False
    if not check:
        raise SvdPatchError("{}: registers cannot be collected into {} cluster"
                            .format(ptag.findtext('name'), cname))
    ctag = ET.SubElement(ptag.find('registers'), 'cluster')
    addressOffset = min([registers[0][2] for _, registers in rdict.items()])
    ET.SubElement(ctag, 'name').text = cname
    if 'description' in cmod:
        description = cmod['description']
    else:
        description = ("Cluster {}, containing {}"
                       .format(cname, ", ".join(rspecs)))
    ET.SubElement(ctag, 'description').text = description
    ET.SubElement(ctag, 'addressOffset').text = hex(addressOffset)
    for rspec, registers in rdict.items():
        for rtag, _, _ in registers[1:]:
            ptag.find('registers').remove(rtag)
        rtag = registers[0][0]
        rmod = cmod[rspec]
        process_peripheral_register(ptag, rspec, rmod)
        new_rtag = copy.deepcopy(rtag)
        ptag.find('registers').remove(rtag)
        if 'name' in rmod:
            name = rmod['name']
        else:
            li, ri = spec_ind(rspec)
            name = rspec[:li]+rspec[len(rspec)-ri:]
        new_rtag.find('name').text = name
        offset = new_rtag.find('addressOffset')
        offset.text = hex(int(offset.text, 0)-addressOffset)
        ctag.append(new_rtag)
    ET.SubElement(ctag, 'dim').text = str(dim)
    ET.SubElement(ctag, 'dimIndex').text = dimIndex
    ET.SubElement(ctag, 'dimIncrement').text = hex(dimIncrement)


class SvdPatchError(ValueError):
    pass


class RegisterMergeError(SvdPatchError):
    pass


class MissingFieldError(SvdPatchError):
    pass


class MissingRegisterError(SvdPatchError):
    pass


class MissingPeripheralError(SvdPatchError):
    pass


def process_register_merge(rtag, fspec):
    """Merge all fspec in rtag."""
    fields = list(iter_fields(rtag, fspec))
    if len(fields) == 0:
        rname = rtag.find('name').text
        raise RegisterMergeError("Could not find any fields to merge {}.{}"
                                 .format(rname, fspec))
    parent = rtag.find('fields')
    name = os.path.commonprefix([f.find('name').text for f in fields])
    desc = fields[0].find('description').text
    bitwidth = sum(int(f.find('bitWidth').text) for f in fields)
    bitoffset = min(int(f.find('bitOffset').text) for f in fields)
    for field in fields:
        parent.remove(field)
    fnew = ET.SubElement(parent, 'field')
    ET.SubElement(fnew, 'name').text = name
    ET.SubElement(fnew, 'description').text = desc
    ET.SubElement(fnew, 'bitOffset').text = str(bitoffset)
    ET.SubElement(fnew, 'bitWidth').text = str(bitwidth)


def process_register_split(rtag, fspec):
    """split all fspec in rtag."""
    fields = list(iter_fields(rtag, fspec))
    if len(fields) == 0:
        rname = rtag.find('name').text
        raise RegisterMergeError("Could not find any fields to split {}.{}"
                                 .format(rname, fspec))
    parent = rtag.find('fields')
    name = os.path.commonprefix([f.find('name').text for f in fields])
    desc = fields[0].find('description').text
    bitwidth = sum(int(f.find('bitWidth').text) for f in fields)
    parent.remove(fields[0])
    for i in range(bitwidth):
        fnew = ET.SubElement(parent, 'field')
        ET.SubElement(fnew, 'name').text = name + str(i)
        ET.SubElement(fnew, 'description').text = desc
        ET.SubElement(fnew, 'bitOffset').text = str(i)
        ET.SubElement(fnew, 'bitWidth').text = str(1)


def process_field_enum(pname, rtag, fspec, field, usage="read-write"):
    """Add an enumeratedValues given by field to all fspec in rtag."""
    replace_if_exists = False
    if "_replace_enum" in field:
        field = field["_replace_enum"]
        replace_if_exists = True

    derived, enum, enum_name, enum_usage = None, None, None, None
    for ftag in iter_fields(rtag, fspec):
        name = ftag.find('name').text

        if enum is None:
            enum = make_enumerated_values(name, field, usage=usage)
            enum_name = enum.find('name').text
            enum_usage = enum.find('usage').text

        for ev in ftag.iter('enumeratedValues'):
            ev_usage_tag = ev.find('usage')
            ev_usage = ev_usage_tag.text if ev_usage_tag is not None else 'read-write'
            if ev_usage == enum_usage or ev_usage == "read-write":
                if replace_if_exists:
                    ftag.remove(ev)
                else:
                    print(pname, fspec, field)
                    raise SvdPatchError(
                        "{}: field {} already has enumeratedValues for {}. Use '_replace_enum' to overwrite."
                        .format(pname, name, ev_usage))

        if derived is None:
            ftag.append(enum)
            derived = make_derived_enumerated_values(enum_name)
        else:
            ftag.append(derived)
    if derived is None:
        rname = rtag.find('name').text
        raise MissingFieldError("Could not find {}:{}.{}"
                                .format(pname, rname, fspec))


def process_field_range(pname, rtag, fspec, field):
    """Add a writeConstraint range given by field to all fspec in rtag."""
    set_any = False
    for ftag in iter_fields(rtag, fspec):
        ftag.append(make_write_constraint(field))
        set_any = True
    if not set_any:
        rname = rtag.find('name').text
        raise MissingFieldError("Could not find {}:{}.{}"
                                .format(pname, rname, fspec))


def process_register_field(pname, rtag, fspec, field):
    """Work through a field, handling either an enum or a range."""
    if isinstance(field, dict):
        usages = ("_read", "_write")

        if not any(u in field for u in usages):
            process_field_enum(pname, rtag, fspec, field)

        for usage in (u for u in usages if u in field):
            process_field_enum(pname, rtag, fspec, field[usage],
                               usage=usage.replace("_", ""))

    elif isinstance(field, list) and len(field) == 2:
        process_field_range(pname, rtag, fspec, field)


def process_peripheral_register(ptag, rspec, register, update_fields=True):
    """Work through a register, handling all fields."""
    # Find all registers that match the spec
    pname = ptag.find('name').text
    rcount = 0
    for rtag in iter_registers(ptag, rspec):
        rcount += 1
        # Handle deletions
        for fspec in register.get("_delete", []):
            process_register_delete(rtag, fspec)
        # Handle modifications
        for fspec in register.get("_modify", []):
            fmod = register["_modify"][fspec]
            process_register_modify(rtag, fspec, fmod)
        # Handle additions
        for fname in register.get("_add", []):
            fadd = register["_add"][fname]
            process_register_add(rtag, fname, fadd)
        # Handle merges
        for fspec in register.get("_merge", []):
            process_register_merge(rtag, fspec)
        # Handle splits
        for fspec in register.get("_split", []):
            process_register_split(rtag, fspec)
        # Handle fields
        if update_fields:
            for fspec in register:
                if not fspec.startswith("_"):
                    field = register[fspec]
                    process_register_field(pname, rtag, fspec, field)
    if rcount == 0:
        raise MissingRegisterError("Could not find {}:{}"
                                   .format(pname, rspec))


def process_peripheral(svd, pspec, peripheral, update_fields=True):
    """Work through a peripheral, handling all registers."""
    # Find all peripherals that match the spec
    pcount = 0
    for ptag in iter_peripherals(svd, pspec):
        pcount += 1
        # Handle deletions
        for rspec in peripheral.get("_delete", []):
            process_peripheral_delete(ptag, rspec)
        # Handle modifications
        for rspec in peripheral.get("_modify", {}):
            rmod = peripheral["_modify"][rspec]
            process_peripheral_modify(ptag, rspec, rmod)
        # Handle strips
        for rspec in peripheral.get("_strip", []):
            process_peripheral_strip(ptag, rspec)
        # Handle additions
        for rname in peripheral.get("_add", {}):
            radd = peripheral["_add"][rname]
            if rname == "_registers":
                for rname in radd:
                    process_peripheral_add_reg(ptag, rname, radd[rname])
            elif rname == "_interrupts":
                for iname in radd:
                    process_peripheral_add_int(ptag, iname, radd[iname])
            else:
                process_peripheral_add_reg(ptag, rname, radd)
        # Handle registers
        for rspec in peripheral:
            if not rspec.startswith("_"):
                register = peripheral[rspec]
                process_peripheral_register(ptag, rspec, register,
                                            update_fields)
        # Handle register arrays
        for rspec in peripheral.get("_array", {}):
            rmod = peripheral["_array"][rspec]
            process_peripheral_regs_array(ptag, rspec, rmod)
        # Handle clusters
        for cname in peripheral.get("_cluster", {}):
            cmod = peripheral["_cluster"][cname]
            process_peripheral_cluster(ptag, cname, cmod)
    if pcount == 0:
        raise MissingPeripheralError("Could not find {}".format(pspec))


def process_device(svd, device, update_fields=True):
    """Work through a device, handling all peripherals"""

    # Handle any deletions
    for pspec in device.get("_delete", []):
        process_device_delete(svd, pspec)

    # Handle any modifications
    for key in device.get("_modify", {}):
        val = device["_modify"][key]
        if key == "cpu":
            process_device_cpu_modify(svd, val)
        elif key == "_peripherals":
            for pspec in val:
                pmod = device['_modify']['_peripherals'][pspec]
                process_device_peripheral_modify(svd, pspec, pmod)
        elif key in DEVICE_CHILDREN:
            process_device_child_modify(svd, key, val)
        else:
            process_device_peripheral_modify(svd, key, val)

    # Handle any new peripherals (!)
    for pname in device.get("_add", []):
        padd = device["_add"][pname]
        process_device_add(svd, pname, padd)

    # Handle any derived peripherals
    for pname in device.get("_derive", []):
        pderive = device["_derive"][pname]
        process_device_derive(svd, pname, pderive)

    # Handle any rebased peripherals
    for pname in device.get("_rebase", []):
        pold = device["_rebase"][pname]
        process_device_rebase(svd, pname, pold)

    # Now process all peripherals
    for periphspec in device:
        if not periphspec.startswith("_"):
            device[periphspec]["_path"] = device["_path"]
            process_peripheral(svd, periphspec, device[periphspec],
                               update_fields)


def main():
    # Load the specified YAML root file
    args = parseargs()
    with open(args.yaml) as f:
        root = yaml.safe_load(f)
        root["_path"] = args.yaml

    # Load the specified SVD file
    svdpath = args.svd_in
    if not os.path.exists(svdpath):
        raise FileNotFoundError("The input SVD file does not exist")
    svdpath_out = args.svd_out
    svd = ET.parse(svdpath)

    # Load all included YAML files
    yaml_includes(root)

    # Process device
    process_device(svd, root)

    # SVD should now be updated, write it out
    svd.write(svdpath_out)


if __name__ == "__main__":
    main()