xref: /external/deqp/scripts/khr_util/registry.py

# -*- coding: utf-8 -*-

#-------------------------------------------------------------------------
# drawElements Quality Program utilities
# --------------------------------------
#
# Copyright 2015 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#-------------------------------------------------------------------------

import sys, logging, re
from lxml import etree
from collections import OrderedDict
from functools import wraps, partial

log = logging.getLogger(__name__)

debug = log.debug
info = log.info
warning = log.warning

def warnElem(elem, fmt, *args):
	warning('%s:%d, %s %s: ' + fmt, elem.base, elem.sourceline, elem.tag, elem.get('name') or '', *args)

class Object(object):
	def __init__(self, **kwargs):
		self.__dict__.update(kwargs)

class Located(Object):
	location = None

class Group(Located): pass
class Enum(Located): pass
class Enums(Located):
	name = None
	comment = None
	enums = None

class Type(Located):
	location = None
	name=None
	definition=None
	api=None
	requires=None

def makeObject(cls, elem, **kwargs):
	kwargs.setdefault('name', elem.get('name'))
	kwargs.setdefault('comment', elem.get('comment'))
	kwargs['location'] = (elem.base, elem.sourceline)
	return cls(**kwargs)

def parseEnum(eEnum):
	return makeObject(
		Enum, eEnum,
		value=eEnum.get('value'),
		type=eEnum.get('type'),
		alias=eEnum.get('alias'))

class Param(Located): pass

class Command(Located):
	name=None
	declaration=None
	type=None
	ptype=None
	group=None
	params=None
	alias=None

class Interface(Object): pass

class Index:
	def __init__(self, items=[], **kwargs):
		self.index = {}
		self.items = []
		self.__dict__.update(kwargs)
		self.update(items)

	def append(self, item):
		keys = self.getkeys(item)
		for key in keys:
			self[key] = item
		self.items.append(item)

	def update(self, items):
		for item in items:
			self.append(item)

	def __iter__(self):
		return iter(self.items)

	def nextkey(self, key):
		raise KeyError

	def getkeys(self, item):
		return []

	def __contains__(self, key):
		return key in self.index

	def __setitem__(self, key, item):
		if key in self.index:
			self.duplicateKey(key, item)
		else:
			self.index[key] = item

	def duplicateKey(self, key, item):
		warning("Duplicate %s: %r", type(item).__name__.lower(), key)

	def __getitem__(self, key):
		try:
			while True:
				try:
					return self.index[key]
				except KeyError:
					pass
				key = self.nextkey(key)
		except KeyError:
			item = self.missingKey(key)
			self.append(item)
			return item

	def missingKey(self, key):
		raise KeyError(key)

	def __len__(self):
		return len(self.items)

class ElemNameIndex(Index):
	def getkeys(self, item):
		return [item.get('name')]

	def duplicateKey(self, key, item):
		warnElem(item, "Duplicate key: %s", key)

class CommandIndex(Index):
	def getkeys(self, item):
		return [item.findtext('proto/name'), item.findtext('alias')]

class NameApiIndex(Index):
	def getkeys(self, item):
		return [(item.get('name'), item.get('api'))]

	def nextkey(self, key):
		if len(key) == 2 and key[1] is not None:
			return key[0], None
		raise KeyError

	def duplicateKey(self, key, item):
		warnElem(item, "Duplicate key: %s", key)

class TypeIndex(NameApiIndex):
	def getkeys(self, item):
		return [(item.get('name') or item.findtext('name'), item.get('api'))]

class EnumIndex(NameApiIndex):
	def getkeys(self, item):
		name, api, alias = (item.get(attrib) for attrib in ['name', 'api', 'alias'])
		return [(name, api)] + ([(alias, api)] if alias is not None else [])

	def duplicateKey(self, (name, api), item):
		if name == item.get('alias'):
			warnElem(item, "Alias already present: %s", name)
		else:
			warnElem(item, "Already present")

class Registry:
	def __init__(self, eRegistry):
		self.types = TypeIndex(eRegistry.findall('types/type'))
		self.groups = ElemNameIndex(eRegistry.findall('groups/group'))
		self.enums = EnumIndex(eRegistry.findall('enums/enum'))
		for eEnum in self.enums:
			groupName = eEnum.get('group')
			if groupName is not None:
				self.groups[groupName] = eEnum
		self.commands = CommandIndex(eRegistry.findall('commands/command'))
		self.features = ElemNameIndex(eRegistry.findall('feature'))
		self.apis = {}
		for eFeature in self.features:
			self.apis.setdefault(eFeature.get('api'), []).append(eFeature)
		for apiFeatures in self.apis.itervalues():
			apiFeatures.sort(key=lambda eFeature: eFeature.get('number'))
		self.extensions = ElemNameIndex(eRegistry.findall('extensions/extension'))
		self.element = eRegistry

	def getFeatures(self, api, checkVersion=None):
		return [eFeature for eFeature in self.apis[api]
				if checkVersion is None or checkVersion(eFeature.get('number'))]

class NameIndex(Index):
	createMissing = None
	kind = "item"

	def getkeys(self, item):
		return [item.name]

	def missingKey(self, key):
		if self.createMissing:
			warning("Reference to implicit %s: %r", self.kind, key)
			return self.createMissing(name=key)
		else:
			raise KeyError

def matchApi(api1, api2):
	return api1 is None or api2 is None or api1 == api2

class Interface(Object):
	pass

def extractAlias(eCommand):
	aliases = eCommand.xpath('alias/@name')
	return aliases[0] if aliases else None

def getExtensionName(eExtension):
	return eExtension.get('name')

def extensionSupports(eExtension, api, profile=None):
	if api == 'gl' and profile == 'core':
		needSupport = 'glcore'
	else:
		needSupport = api
	supporteds = eExtension.get('supported').split('|')
	return needSupport in supporteds

class InterfaceSpec(Object):
	def __init__(self):
		self.enums = set()
		self.types = set()
		self.commands = set()
		self.versions = set()

	def addComponent(self, eComponent):
		if eComponent.tag == 'require':
			def modify(items, item): items.add(item)
		else:
			assert eComponent.tag == 'remove'
			def modify(items, item):
				try:
					items.remove(item)
				except KeyError:
					warning("Tried to remove absent item: %s", item)
		for typeName in eComponent.xpath('type/@name'):
			modify(self.types, typeName)
		for enumName in eComponent.xpath('enum/@name'):
			modify(self.enums, enumName)
		for commandName in eComponent.xpath('command/@name'):
			modify(self.commands, commandName)

	def addComponents(self, elem, api, profile=None):
		for eComponent in elem.xpath('require|remove'):
			cApi = eComponent.get('api')
			cProfile = eComponent.get('profile')
			if (matchApi(api, eComponent.get('api')) and
				matchApi(profile, eComponent.get('profile'))):
				self.addComponent(eComponent)

	def addFeature(self, eFeature, api=None, profile=None, force=False):
		info('Feature %s', eFeature.get('name'))
		if not matchApi(api, eFeature.get('api')):
			if not force: return
			warnElem(eFeature, 'API %s is not supported', api)
		self.addComponents(eFeature, api, profile)
		self.versions.add(eFeature.get('name'))

	def addExtension(self, eExtension, api=None, profile=None, force=False):
		if not extensionSupports(eExtension, api, profile):
			if not force: return
			warnElem(eExtension, '%s is not supported in API %s' % (getExtensionName(eExtension), api))
		self.addComponents(eExtension, api, profile)

def createInterface(registry, spec, api=None):
	def parseType(eType):
		# todo: apientry
		#requires = eType.get('requires')
		#if requires is not None:
		#    types[requires]
		return makeObject(
			Type, eType,
			name=eType.get('name') or eType.findtext('name'),
			definition=''.join(eType.xpath('.//text()')),
			api=eType.get('api'),
			requires=eType.get('requires'))

	def createType(name):
		info('Add type %s', name)
		try:
			return parseType(registry.types[name, api])
		except KeyError:
			return Type(name=name)

	def createEnum(enumName):
		info('Add enum %s', enumName)
		return parseEnum(registry.enums[enumName, api])

	def extractPtype(elem):
		ePtype = elem.find('ptype')
		if ePtype is None:
			return None
		return types[ePtype.text]

	def extractGroup(elem):
		groupName = elem.get('group')
		if groupName is None:
			return None
		return groups[groupName]

	def parseParam(eParam):
		return makeObject(
			Param, eParam,
			name=eParam.get('name') or eParam.findtext('name'),
			declaration=''.join(eParam.xpath('.//text()')).strip(),
			type=''.join(eParam.xpath('(.|ptype)/text()')).strip(),
			ptype=extractPtype(eParam),
			group=extractGroup(eParam))

	def createCommand(commandName):
		info('Add command %s', commandName)
		eCmd = registry.commands[commandName]
		eProto = eCmd.find('proto')
		return makeObject(
			Command, eCmd,
			name=eCmd.findtext('proto/name'),
			declaration=''.join(eProto.xpath('.//text()')).strip(),
			type=''.join(eProto.xpath('(.|ptype)/text()')).strip(),
			ptype=extractPtype(eProto),
			group=extractGroup(eProto),
			alias=extractAlias(eCmd),
			params=NameIndex(map(parseParam, eCmd.findall('param'))))

	def createGroup(name):
		info('Add group %s', name)
		try:
			eGroup = registry.groups[name]
		except KeyError:
			return Group(name=name)
		return makeObject(
			Group, eGroup,
			# Missing enums are often from exotic extensions. Don't create dummy entries,
			# just filter them out.
			enums=NameIndex(enums[name] for name in eGroup.xpath('enum/@name')
							if name in enums))

	def sortedIndex(items):
		return NameIndex(sorted(items, key=lambda item: item.location))

	groups = NameIndex(createMissing=createGroup, kind="group")
	types = NameIndex(map(createType, spec.types),
					  createMissing=createType, kind="type")
	enums = NameIndex(map(createEnum, spec.enums),
					  createMissing=Enum, kind="enum")
	commands = NameIndex(map(createCommand, spec.commands),
						createMissing=Command, kind="command")
	versions = sorted(spec.versions)

	# This is a mess because the registry contains alias chains whose
	# midpoints might not be included in the interface even though
	# endpoints are.
	for command in commands:
		alias = command.alias
		aliasCommand = None
		while alias is not None:
			aliasCommand = registry.commands[alias]
			alias = extractAlias(aliasCommand)
		command.alias = None
		if aliasCommand is not None:
			name = aliasCommand.findtext('proto/name')
			if name in commands:
				command.alias = commands[name]

	return Interface(
		types=sortedIndex(types),
		enums=sortedIndex(enums),
		groups=sortedIndex(groups),
		commands=sortedIndex(commands),
		versions=versions)


def spec(registry, api, version=None, profile=None, extensionNames=[], protects=[], force=False):
	available = set(protects)
	spec = InterfaceSpec()

	if version is None or version is False:
		def check(v): return False
	elif version is True:
		def check(v): return True
	else:
		def check(v): return v <= version

	for eFeature in registry.getFeatures(api, check):
		spec.addFeature(eFeature, api, profile, force)

	for extName in extensionNames:
		eExtension = registry.extensions[extName]
		protect = eExtension.get('protect')
		if protect is not None and protect not in available:
			warnElem(eExtension, "Unavailable dependency %s", protect)
			if not force:
				continue
		spec.addExtension(eExtension, api, profile, force)
		available.add(extName)

	return spec

def interface(registry, api, **kwargs):
	s = spec(registry, api, **kwargs)
	return createInterface(registry, s, api)

def parse(path):
	return Registry(etree.parse(path))