1 # -*- coding: utf-8 -*-
3 #-------------------------------------------------------------------------
4 # drawElements Quality Program utilities
5 # --------------------------------------
7 # Copyright 2015 The Android Open Source Project
9 # Licensed under the Apache License, Version 2.0 (the "License");
10 # you may not use this file except in compliance with the License.
11 # You may obtain a copy of the License at
13 # http://www.apache.org/licenses/LICENSE-2.0
15 # Unless required by applicable law or agreed to in writing, software
16 # distributed under the License is distributed on an "AS IS" BASIS,
17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 # See the License for the specific language governing permissions and
19 # limitations under the License.
21 #-------------------------------------------------------------------------
23 import sys, logging, re
24 from lxml import etree
25 from collections import OrderedDict
26 from functools import wraps, partial
28 log = logging.getLogger(__name__)
34 def warnElem(elem, fmt, *args):
35 warning('%s:%d, %s %s: ' + fmt, elem.base, elem.sourceline, elem.tag, elem.get('name') or '', *args)
38 def __init__(self, **kwargs):
39 self.__dict__.update(kwargs)
41 class Located(Object):
44 class Group(Located): pass
45 class Enum(Located): pass
58 def makeObject(cls, elem, **kwargs):
59 kwargs.setdefault('name', elem.get('name'))
60 kwargs.setdefault('comment', elem.get('comment'))
61 kwargs['location'] = (elem.base, elem.sourceline)
67 value=eEnum.get('value'),
68 type=eEnum.get('type'),
69 alias=eEnum.get('alias'))
71 class Param(Located): pass
73 class Command(Located):
82 class Interface(Object): pass
85 def __init__(self, items=[], **kwargs):
88 self.__dict__.update(kwargs)
91 def append(self, item):
92 keys = self.getkeys(item)
95 self.items.append(item)
97 def update(self, items):
102 return iter(self.items)
104 def nextkey(self, key):
107 def getkeys(self, item):
110 def __contains__(self, key):
111 return key in self.index
113 def __setitem__(self, key, item):
114 if key in self.index:
115 self.duplicateKey(key, item)
117 self.index[key] = item
119 def duplicateKey(self, key, item):
120 warning("Duplicate %s: %r", type(item).__name__.lower(), key)
122 def __getitem__(self, key):
126 return self.index[key]
129 key = self.nextkey(key)
131 item = self.missingKey(key)
135 def missingKey(self, key):
139 return len(self.items)
141 class ElemNameIndex(Index):
142 def getkeys(self, item):
143 return [item.get('name')]
145 def duplicateKey(self, key, item):
146 warnElem(item, "Duplicate key: %s", key)
148 class CommandIndex(Index):
149 def getkeys(self, item):
150 return [item.findtext('proto/name'), item.findtext('alias')]
152 class NameApiIndex(Index):
153 def getkeys(self, item):
154 return [(item.get('name'), item.get('api'))]
156 def nextkey(self, key):
157 if len(key) == 2 and key[1] is not None:
161 def duplicateKey(self, key, item):
162 warnElem(item, "Duplicate key: %s", key)
164 class TypeIndex(NameApiIndex):
165 def getkeys(self, item):
166 return [(item.get('name') or item.findtext('name'), item.get('api'))]
168 class EnumIndex(NameApiIndex):
169 def getkeys(self, item):
170 name, api, alias = (item.get(attrib) for attrib in ['name', 'api', 'alias'])
171 return [(name, api)] + ([(alias, api)] if alias is not None else [])
173 def duplicateKey(self, (name, api), item):
174 if name == item.get('alias'):
175 warnElem(item, "Alias already present: %s", name)
177 warnElem(item, "Already present")
180 def __init__(self, eRegistry):
181 self.types = TypeIndex(eRegistry.findall('types/type'))
182 self.groups = ElemNameIndex(eRegistry.findall('groups/group'))
183 self.enums = EnumIndex(eRegistry.findall('enums/enum'))
184 for eEnum in self.enums:
185 groupName = eEnum.get('group')
186 if groupName is not None:
187 self.groups[groupName] = eEnum
188 self.commands = CommandIndex(eRegistry.findall('commands/command'))
189 self.features = ElemNameIndex(eRegistry.findall('feature'))
191 for eFeature in self.features:
192 self.apis.setdefault(eFeature.get('api'), []).append(eFeature)
193 for apiFeatures in self.apis.itervalues():
194 apiFeatures.sort(key=lambda eFeature: eFeature.get('number'))
195 self.extensions = ElemNameIndex(eRegistry.findall('extensions/extension'))
196 self.element = eRegistry
198 def getFeatures(self, api, checkVersion=None):
199 return [eFeature for eFeature in self.apis[api]
200 if checkVersion is None or checkVersion(eFeature.get('number'))]
202 class NameIndex(Index):
206 def getkeys(self, item):
209 def missingKey(self, key):
210 if self.createMissing:
211 warning("Reference to implicit %s: %r", self.kind, key)
212 return self.createMissing(name=key)
216 def matchApi(api1, api2):
217 return api1 is None or api2 is None or api1 == api2
219 class Interface(Object):
222 def extractAlias(eCommand):
223 aliases = eCommand.xpath('alias/@name')
224 return aliases[0] if aliases else None
226 def getExtensionName(eExtension):
227 return eExtension.get('name')
229 def extensionSupports(eExtension, api, profile=None):
230 if api == 'gl' and profile == 'core':
231 needSupport = 'glcore'
234 supporteds = eExtension.get('supported').split('|')
235 return needSupport in supporteds
237 class InterfaceSpec(Object):
241 self.commands = set()
242 self.versions = set()
244 def addComponent(self, eComponent):
245 if eComponent.tag == 'require':
246 def modify(items, item): items.add(item)
248 assert eComponent.tag == 'remove'
249 def modify(items, item):
253 warning("Tried to remove absent item: %s", item)
254 for typeName in eComponent.xpath('type/@name'):
255 modify(self.types, typeName)
256 for enumName in eComponent.xpath('enum/@name'):
257 modify(self.enums, enumName)
258 for commandName in eComponent.xpath('command/@name'):
259 modify(self.commands, commandName)
261 def addComponents(self, elem, api, profile=None):
262 for eComponent in elem.xpath('require|remove'):
263 cApi = eComponent.get('api')
264 cProfile = eComponent.get('profile')
265 if (matchApi(api, eComponent.get('api')) and
266 matchApi(profile, eComponent.get('profile'))):
267 self.addComponent(eComponent)
269 def addFeature(self, eFeature, api=None, profile=None, force=False):
270 info('Feature %s', eFeature.get('name'))
271 if not matchApi(api, eFeature.get('api')):
273 warnElem(eFeature, 'API %s is not supported', api)
274 self.addComponents(eFeature, api, profile)
275 self.versions.add(eFeature.get('name'))
277 def addExtension(self, eExtension, api=None, profile=None, force=False):
278 if not extensionSupports(eExtension, api, profile):
280 warnElem(eExtension, '%s is not supported in API %s' % (getExtensionName(eExtension), api))
281 self.addComponents(eExtension, api, profile)
283 def createInterface(registry, spec, api=None):
284 def parseType(eType):
286 #requires = eType.get('requires')
287 #if requires is not None:
291 name=eType.get('name') or eType.findtext('name'),
292 definition=''.join(eType.xpath('.//text()')),
293 api=eType.get('api'),
294 requires=eType.get('requires'))
296 def createType(name):
297 info('Add type %s', name)
299 return parseType(registry.types[name, api])
301 return Type(name=name)
303 def createEnum(enumName):
304 info('Add enum %s', enumName)
305 return parseEnum(registry.enums[enumName, api])
307 def extractPtype(elem):
308 ePtype = elem.find('ptype')
311 return types[ePtype.text]
313 def extractGroup(elem):
314 groupName = elem.get('group')
315 if groupName is None:
317 return groups[groupName]
319 def parseParam(eParam):
322 name=eParam.get('name') or eParam.findtext('name'),
323 declaration=''.join(eParam.xpath('.//text()')).strip(),
324 type=''.join(eParam.xpath('(.|ptype)/text()')).strip(),
325 ptype=extractPtype(eParam),
326 group=extractGroup(eParam))
328 def createCommand(commandName):
329 info('Add command %s', commandName)
330 eCmd = registry.commands[commandName]
331 eProto = eCmd.find('proto')
334 name=eCmd.findtext('proto/name'),
335 declaration=''.join(eProto.xpath('.//text()')).strip(),
336 type=''.join(eProto.xpath('(.|ptype)/text()')).strip(),
337 ptype=extractPtype(eProto),
338 group=extractGroup(eProto),
339 alias=extractAlias(eCmd),
340 params=NameIndex(map(parseParam, eCmd.findall('param'))))
342 def createGroup(name):
343 info('Add group %s', name)
345 eGroup = registry.groups[name]
347 return Group(name=name)
350 # Missing enums are often from exotic extensions. Don't create dummy entries,
351 # just filter them out.
352 enums=NameIndex(enums[name] for name in eGroup.xpath('enum/@name')
355 def sortedIndex(items):
356 return NameIndex(sorted(items, key=lambda item: item.location))
358 groups = NameIndex(createMissing=createGroup, kind="group")
359 types = NameIndex(map(createType, spec.types),
360 createMissing=createType, kind="type")
361 enums = NameIndex(map(createEnum, spec.enums),
362 createMissing=Enum, kind="enum")
363 commands = NameIndex(map(createCommand, spec.commands),
364 createMissing=Command, kind="command")
365 versions = sorted(spec.versions)
367 # This is a mess because the registry contains alias chains whose
368 # midpoints might not be included in the interface even though
370 for command in commands:
371 alias = command.alias
373 while alias is not None:
374 aliasCommand = registry.commands[alias]
375 alias = extractAlias(aliasCommand)
377 if aliasCommand is not None:
378 name = aliasCommand.findtext('proto/name')
380 command.alias = commands[name]
383 types=sortedIndex(types),
384 enums=sortedIndex(enums),
385 groups=sortedIndex(groups),
386 commands=sortedIndex(commands),
390 def spec(registry, api, version=None, profile=None, extensionNames=[], protects=[], force=False):
391 available = set(protects)
392 spec = InterfaceSpec()
394 if version is None or version is False:
395 def check(v): return False
396 elif version is True:
397 def check(v): return True
399 def check(v): return v <= version
401 for eFeature in registry.getFeatures(api, check):
402 spec.addFeature(eFeature, api, profile, force)
404 for extName in extensionNames:
405 eExtension = registry.extensions[extName]
406 protect = eExtension.get('protect')
407 if protect is not None and protect not in available:
408 warnElem(eExtension, "Unavailable dependency %s", protect)
411 spec.addExtension(eExtension, api, profile, force)
412 available.add(extName)
416 def interface(registry, api, **kwargs):
417 s = spec(registry, api, **kwargs)
418 return createInterface(registry, s, api)
421 return Registry(etree.parse(path))