Debian Codegraph @

xml2lst

raw
1 #!/usr/bin/python3
2
3 # xml2lst - convert Discover 2 XML files back to Discover 1 format
4
5 import sys
6 import optparse
7 import string
8 import re
9 import xml.sax
10 import xml.sax.handler
11
12 recognized_data_paths = { "linux/module/name": "%s",
13 "xfree86/server/device/driver": "Server:XFree86(%s)",
14 "xfree86/server/name": "Server:%s"
15 }
16 recognized_precedence = ("xfree86/server/device/driver",
17 "xfree86/server/name", "linux/module/name")
18
19 class DeviceHandler(xml.sax.handler.ContentHandler):
20 def __init__(self, busclass, vendor, old_busclass_list, versions,
21 explicit_version):
22 self.busclasses = busclass
23 self.vendors = vendor
24 self.old_busclasses = old_busclass_list
25 self.versions = versions
26 self.explicit_version = explicit_version
27
28 self.devices = {}
29 for vendor in self.vendors.keys():
30 self.devices[vendor] = {}
31
32 self.clearDevice()
33
34 def clearDevice(self):
35 self.current_device = None
36 self.current_device_items = {}
37 self.data_path = []
38 self.data_version = None
39 self.data_version_node = None
40 self.content = ""
41
42 def startElement(self, name, attrs):
43 if name == 'data':
44 # This code fail to take into account that there might be
45 # several data tags with different version settings.
46 if attrs.has_key("version"):
47 self.data_version = attrs["version"]
48 self.data_version_node = attrs["class"]
49 self.data_path.append(attrs["class"])
50 elif name == 'device':
51 self.clearDevice()
52 self.current_device = attrs.copy()
53
54 def endElement(self, name):
55 if name == 'data':
56 data_key = string.join(self.data_path, "/")
57 if not self.current_device_items.has_key(data_key):
58 self.current_device_items[data_key] = []
59 if len(self.content) > 0:
60 self.current_device_items[data_key].append((self.content.strip(),
61 self.data_version))
62 self.content = ""
63
64 old_class = self.data_path.pop()
65 if old_class == self.data_version_node:
66 self.data_version = None
67 self.data_version_node = None
68 elif name == 'device':
69 self.saveDevice()
70 self.clearDevice()
71
72 def characters(self, content):
73 if len(self.data_path) < 1 or \
74 not re.search(r'\S+', content):
75 return
76
77 self.content += content
78
79 def saveDevice(self):
80 item = {}
81 if self.current_device.has_key("subvendor"):
82 return # discover 1 do not understand subvendors, ignore entry
83 vendor_model_id = self.current_device["vendor"] + self.current_device["model"]
84 if self.current_device.has_key("busclass"):
85 item["busclass"] = self.busclasses[self.current_device["busclass"]]
86 elif self.old_busclasses.has_key(vendor_model_id):
87 item["busclass"] = self.old_busclasses[vendor_model_id][0]
88 else:
89 item["busclass"] = "unknown"
90 item["name"] = self.current_device["model_name"]
91
92 if self.old_busclasses.has_key(vendor_model_id):
93 item["driver"] = self.old_busclasses[vendor_model_id][1]
94 else:
95 item["driver"] = "unknown"
96
97 found = False
98 for key in recognized_precedence:
99 if not self.current_device_items.has_key(key):
100 continue
101
102 for (content, version) in self.current_device_items[key]:
103 if self.explicit_version and version is None:
104 continue
105 if self.versions.has_key(key) and \
106 version is not None and \
107 not version_in_set(version, self.versions[key]):
108 continue
109 item["driver"] = recognized_data_paths[key] % (content,)
110 found = True
111 break
112 if found:
113 break
114
115 vendor = self.current_device["vendor"]
116 model = self.current_device["model"]
117 self.devices[vendor][model] = item
118
119 def version_compare(ver1, ver2):
120 """Return negative if the second version is bigger, positive if the
121 first version is bigger, or zero if the versions are equal."""
122
123 if ver1 == ver2:
124 return 0
125 elif ver1 == "inf":
126 return 1
127 elif ver2 == "inf":
128 return -1
129
130 ver1_parts = map(lambda x: int(x), string.split(ver1, "."))
131 ver2_parts = map(lambda x: int(x), string.split(ver2, "."))
132 ver1_len = len(ver1_parts)
133 ver2_len = len(ver2_parts)
134
135 if ver1_len > ver2_len:
136 compare_len = ver2_len
137 else:
138 compare_len = ver1_len
139
140 for i in range(0, compare_len):
141 if ver1_parts[i] != ver2_parts[i]:
142 return ver1_parts[i] - ver2_parts[i]
143
144 return ver1_len - ver2_len
145
146 def version_in_set(set, version):
147 (low_version, high_version) = re.split(r",\s*", set[1:-1], 1)
148 low_inclusive = set[0] == "["
149 high_inclusive = set[-1] == "]"
150
151 low_comp = version_compare(low_version, version)
152 if low_comp > 0 or (low_comp == 0 and not low_inclusive):
153 return False
154
155 high_comp = version_compare(version, high_version)
156 if high_comp > 0 or (high_comp == 0 and not high_inclusive):
157 return False
158
159 return True
160
161 def load_id_db(infile):
162 class IdHandler(xml.sax.handler.ContentHandler):
163 def __init__(self):
164 self.idmap = {}
165
166 def startElement(self, name, attrs):
167 if len(filter(lambda x: x not in ('id', 'name'),
168 attrs.keys())) == 0:
169 self.idmap[attrs['id']] = attrs['name']
170
171 def getResults(self):
172 return self.idmap
173
174 handler = IdHandler()
175 xml.sax.parse(infile, handler)
176 return handler.getResults()
177
178 def main():
179 usage = "usage: %prog [options] busclass_file vendor_file device_file"
180 cmdline = optparse.OptionParser(usage)
181 cmdline.add_option("-o", dest="output_fn", metavar="FILE",
182 help="file to write instead of stdout")
183 cmdline.add_option("--previous-file", dest="input_fn", default=None,
184 metavar="FILE",
185 help="previous lst file to base updates on")
186 cmdline.add_option("--data-version", dest="data_versions", action="append",
187 default=[], metavar="path:version",
188 help="limit output for path to version")
189 cmdline.add_option("--explicit-version", dest="explicit_version",
190 action="store_true", default=False,
191 help="skip data missing version info")
192 (options, args) = cmdline.parse_args()
193 (busclass_fn, vendor_fn, device_fn) = args
194
195 old_busclasses = {}
196 old_vendors = []
197 if options.input_fn:
198 input_file = open(options.input_fn)
199 for line in input_file:
200 if line[0] not in string.whitespace:
201 (id, rest) = string.split(line, None, 1)
202 old_vendors.append(id)
203 else:
204 (id, busclass, module, rest) = \
205 string.split(string.lstrip(line), None, 3)
206 if busclass == "unknown":
207 continue
208 old_busclasses[id] = (busclass, module)
209
210 input_file.close()
211
212 if options.output_fn:
213 output_file = open(options.output_fn, "w")
214 else:
215 output_file = sys.stdout
216
217 version_dict = {}
218 if options.data_versions:
219 for optstr in options.data_versions:
220 (path, ver) = string.split(optstr, ":", 1)
221 version_dict[path] = ver
222
223 busclasses = load_id_db(busclass_fn)
224 vendors = load_id_db(vendor_fn)
225
226 parser = DeviceHandler(busclasses, vendors, old_busclasses, version_dict,
227 options.explicit_version)
228 xml.sax.parse(device_fn, parser)
229
230 vendor_ids = vendors.keys()
231 vendor_ids.sort()
232 for vendor in vendor_ids:
233 device_ids = parser.devices[vendor].keys()
234 if len(device_ids) < 1:
235 if vendor not in old_vendors:
236 continue
237
238 result_unicode = "%s %s\n" % (vendor, vendors[vendor])
239 output_file.write(result_unicode.encode("iso-8859-1"))
240
241 device_ids.sort()
242 for device in device_ids:
243 vendor_out = vendor
244 device_out = device
245 if 'default' == device:
246 vendor_out = 'ffff'
247 device_out = 'ffff'
248 result_unicode = "\t%s%s\t%s\t%s\t%s\n" \
249 % (vendor_out, device_out,
250 parser.devices[vendor][device]["busclass"],
251 parser.devices[vendor][device]["driver"],
252 parser.devices[vendor][device]["name"])
253 output_file.write(result_unicode.encode("iso-8859-1"))
254
255 if __name__ == "__main__":
256 main()