HOME

5h-3LL 1.0
DIR: /usr/share/tools
/usr/share/tools/
Current File : /usr/share/tools/reduce-xml
#!/usr/bin/python
#
# Cuts out all the cruft for the udeb packages.

import sys
import os
import string
import re
import traceback
import getopt
import xml.dom
import xml.dom.minidom

try:
    True
except:
    True = 1
    False = 0

config = { "filelist": [],
           "outfile": "-",
           "outtype": "device",
           "includebus": [],
           "excludebus": [],
           "classspec": [],
           "classversion": "",
           "modlistfile": "",
           "debug": False
         }

toplevel_nodes = { "device": "device_list",
                   "vendor": "vendor_list"
                 }

class UsageError(RuntimeError):
    pass

def compare_versions(x, y):
    x_pieces = string.split(x, ".")
    y_pieces = string.split(y, ".")
    index = 0
    while index < len(x_pieces) and index < len(y_pieces):
        if int(x_pieces[index]) != int(y_pieces[index]):
            return cmp(int(x_pieces[index]), int(y_pieces[index]))
        index = index + 1

    return cmp(len(x_pieces), len(y_pieces))

def check_version(set_spec, version):
    if string.find(set_spec, "inf") != -1:
        pass

    include_left = (set_spec[0] == "[")
    include_right = (set_spec[-1] == "]")
    (left_version, right_version) = re.split(r',\s*', set_spec[1:-1])

    if left_version == "inf":
        left_compare = -1
    else:
        left_compare = compare_versions(left_version, version)
    if right_version == "inf":
        right_compare = 1
    else:
        right_compare = compare_versions(version, right_version)

    if left_compare < 0 and right_compare < 0:
        return True
    if left_compare == 0 and include_left:
        return True
    if right_compare == 0 and include_right:
        return True

    return False

def get_busclass(device_node, busclass_docs):
    if not device_node.attributes.has_key("busclass"):
        return None

    device_id = device_node.attributes["busclass"].value
    for doc in busclass_docs:
        for node in doc.documentElement.childNodes:
            if node.nodeType != xml.dom.Node.ELEMENT_NODE:
                continue

            id = node.attributes["id"].value
            if id == device_id:
                return node.attributes["name"].value

    return None

def find_spec(spec, node):
    try:
        (spec_name, spec_rest) = string.split(spec, ":", 1)
    except:
        spec_name = spec
        spec_rest = None

    node_name = node.attributes["class"]
    if node_name is None:
        return False

    node_name = node_name.value
    if node_name == spec_name:
        if spec_rest is None:
            return True
        elif spec_rest[0] in string.digits:
            spec_version = spec_rest
            try:
                node_version_spec = node.attributes["version"]
            except KeyError:
                return True

            return check_version(node_version_spec.value, spec_version)
        else:
            for child_node in node.childNodes:
                if child_node.nodeType != xml.dom.Node.ELEMENT_NODE:
                    continue
                if find_spec(spec_rest, child_node):
                    return True
            return False
    else:
        return False

def usage(f):
    f.write("need usage statement\n")

def main():
    global config
    global toplevel_nodes

    try:

        # Parse options

        (options, args) = getopt.getopt(sys.argv[1:], "di:o:",
                                        ["input-file=", "output-file=",
                                         "output-type=",
                                         "include-bus=",
                                         "exclude-bus=", "class-spec=",
                                         "module-list=",
                                         "debug"])
        for option in options:
            if option[0] in ("-i", "--input-file"):
                config["filelist"].append(option[1])
            elif option[0] in ("-o", "--output-file"):
                config["outfile"] = option[1]
            elif option[0] == "--output-type":
                config["outtype"] = option[1]
            elif option[0] == "--include-bus":
                config["includebus"].extend(string.split(option[1], ","))
            elif option[0] == "--exclude-bus":
                config["excludebus"].extend(string.split(option[1], ","))
            elif option[0] == "--class-spec":
                config["classspec"].append(option[1])
            elif option[0] == "--module-list":
                config["modlistfile"] = option[1]
            elif option[0] in ("-d", "--debug"):
                config["debug"] = True
            else:
                raise UsageError, "invalid option: %s" % (option[0],)

        # Sanity-check options

        if len(config["filelist"]) == 0:
            raise UsageError, "need input busclass, vendor, and device files"
        if len(config["classspec"]) == 0:
            raise UsageError, "need at least one class specification"

        # Load module list information if present

        modlist = []
        if config["modlistfile"] and os.path.exists(config["modlistfile"]):
            modlistfile = open(config["modlistfile"])
            for line in modlistfile:
                modlist.append(string.strip(line))
            modlistfile.close()

        # Load files

        bus_info = {}
        for fn in config["filelist"]:
            try:
                document = xml.dom.minidom.parse(fn)
                bus_id = document.documentElement.attributes["bus"].value
            except:
                sys.stderr.write("warning: couldn't parse %s, skipping.\n"
                                 % (fn,))
                continue

            if not bus_info.has_key(bus_id):
                bus_info[bus_id] = { "busclass": [],
                                     "vendor": [],
                                     "device": [] }
            data_type = document.documentElement.tagName[:-5]
            try:
                bus_info[bus_id][data_type].append(document)
            except:
                sys.stderr.write("warning: invalid file %s, continuing.\n"
                                 % (fn,))

        # Sanity-check file information

        if len(bus_info.keys()) != 1:
            raise RuntimeError, \
                  "one and only one bus type can be used at a time"
        bus_data = bus_info[bus_info.keys()[0]]
        for bus_type in ("busclass", "device"):
            if len(bus_data[bus_type]) == 0:
                raise RuntimeError, \
                      "required data for bus %s missing, aborting" \
                      % (bus_type,)

        # Create output device document

        outtype = config["outtype"]
        out = bus_data[outtype][0].implementation.createDocument(None, toplevel_nodes[outtype], None)
        out.documentElement.setAttribute("bus", bus_info.keys()[0])

        # Iterate over the input device document, copying nodes we
        # don't want to strip to the output document.

        attr_list = []
        for device_doc in bus_data["device"]:
            for device_node in device_doc.documentElement.childNodes:
                if device_node.nodeType != xml.dom.Node.ELEMENT_NODE:
                    continue

                is_approved_busclass = True
                do_device_node = False
                module_in_list = False
                new_device_node = None
                busclass = get_busclass(device_node, bus_data["busclass"])
                if busclass is None or \
                   busclass in config["excludebus"]:
                    is_approved_busclass = False
                if len(config["includebus"]) > 0 and \
                   busclass not in config["includebus"]:
                    is_approved_busclass = False

                for data_node in device_node.childNodes:
                    if data_node.nodeType != xml.dom.Node.ELEMENT_NODE:
                        continue
                    do_data_node = False
                    for spec in config["classspec"]:
                        if find_spec(spec, data_node):
                            npath = ["module", "name"]
                            nnode = data_node.childNodes[0]
                            while len(npath) > 0 and nnode is not None:
                                while nnode is not None and \
                                        nnode.nodeType != \
                                        xml.dom.Node.ELEMENT_NODE:
                                    nnode = nnode.nextSibling
                                if nnode is None:
                                    continue
                                if nnode.getAttribute("class") == npath[0]:
                                    nnode = nnode.childNodes[0]
                                    npath.pop(0)
                                else:
                                    nnode = nnode.nextSibling

                            if nnode is not None:
                                module_name = string.strip(nnode.nodeValue)
                                if module_name in modlist:
                                    module_in_list = True
                                    break
                                elif module_name not in ("ignore", "unknown"):
                                    do_data_node = True
                                    break

                    if module_in_list or \
                       (do_data_node and is_approved_busclass):
                        do_device_node = True
                        if outtype == "device":
                            if new_device_node is None:
                                new_device_node = device_node.cloneNode(False)
                            new_data_node = data_node.cloneNode(False)
                            for mod_node in data_node.childNodes:
                                if mod_node.nodeType != xml.dom.Node.ELEMENT_NODE:
                                    continue
                                if mod_node.getAttribute("class") != "module":
                                    continue
                                new_mod_node = mod_node.cloneNode(True)
                                new_data_node.appendChild(new_mod_node)
                                break
                            new_device_node.appendChild(new_data_node)

                if do_device_node:
                    if outtype == "device":
                        out.documentElement.appendChild(new_device_node)
                    else:
                        attr_list.append(device_node.getAttribute(outtype))

        # If we're reducing something besides the device list, create
        # that reduced document here.

        if outtype != "device":
            for doc in bus_data[outtype]:
                for node in doc.documentElement.childNodes:
                    if node.nodeType != xml.dom.Node.ELEMENT_NODE:
                        continue
                    if node.getAttribute("id") in attr_list:
                        new_node = node.cloneNode(True)
                        out.documentElement.appendChild(new_node)

        # Write the output document

        if config["outfile"] == "-":
            out_file = sys.stdout
        else:
            out_file = open(config["outfile"], "w")

        out.writexml(out_file, encoding="UTF-8")

    except UsageError, e:
        sys.stderr.write(sys.argv[0] + ": " + str(e) + "\n")
        if config["debug"]:
            traceback.print_exc(None, sys.stderr)
        usage(sys.stderr)
        sys.exit(1)
    except Exception, e:
        sys.stderr.write(sys.argv[0] + ": " + str(e) + "\n")
        if config["debug"]:
            traceback.print_exc(None, sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()