src/vulkan/runtime/vk_format_info_gen.py - third_party/mesa - Git at Google

 COPYRIGHT=u"""
 /* Copyright © 2022 Collabora, Ltd.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
 """

 import argparse
 import os
 import re
 from collections import namedtuple
 import xml.etree.ElementTree as et

 from mako.template import Template

 TEMPLATE_H = Template(COPYRIGHT + """\
 /* This file generated from ${filename}, don't edit directly. */

 #ifndef VK_FORMAT_INFO_H
 #define VK_FORMAT_INFO_H

 #include <vulkan/vulkan_core.h>

 #ifdef __cplusplus
 extern "C" {
 #endif

 enum vk_format_class {
    MESA_VK_FORMAT_CLASS_UNKNOWN,
 % for name in format_classes:
    ${to_enum_name('MESA_VK_FORMAT_CLASS_', name)},
 % endfor
 };

 struct vk_format_class_info {
    const VkFormat *formats;
    uint32_t format_count;
 };

 const struct vk_format_class_info *
 vk_format_class_get_info(enum vk_format_class class);

 const struct vk_format_class_info *
 vk_format_get_class_info(VkFormat format);

 #ifdef __cplusplus
 }
 #endif

 #endif
 """)

 TEMPLATE_C = Template(COPYRIGHT + """
 /* This file generated from ${filename}, don't edit directly. */

 #include "${header}"

 #include "util/macros.h"

 #include "vk_format.h"

 struct vk_format_info {
    enum vk_format_class class;
 };

 % for id, ext in extensions.items():
 static const struct vk_format_info ext${id}_format_infos[] = {
 %   for name, format in ext.formats.items():
    [${format.offset}] = {
       .class = ${to_enum_name('MESA_VK_FORMAT_CLASS_', format.cls)},
    },
 %   endfor
 };

 % endfor
 static const struct vk_format_info *
 vk_format_get_info(VkFormat format)
 {
    uint32_t extnumber =
       format < 1000000000 ? 0 : (((format % 1000000000) / 1000) + 1);
    uint32_t offset = format % 1000;

    switch (extnumber) {
 % for id, ext in extensions.items():
    case ${id}:
       assert(offset < ARRAY_SIZE(ext${id}_format_infos));
       return &ext${id}_format_infos[offset];
 % endfor
    default:
       unreachable("Invalid extension");
    }
 }

 % for clsname, cls in format_classes.items():
 %   if len(cls.formats) > 0:
 static const VkFormat ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}[] = {
 %     for fname in cls.formats:
    ${fname},
 %     endfor
 %   endif
 };

 % endfor
 static const struct vk_format_class_info class_infos[] = {
 % for clsname, cls in format_classes.items():
    [${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname)}] = {
 %   if len(cls.formats) > 0:
       .formats = ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'},
       .format_count = ARRAY_SIZE(${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}),
 %   else:
       0
 %   endif
    },
 % endfor
 };

 const struct vk_format_class_info *
 vk_format_class_get_info(enum vk_format_class class)
 {
    assert(class < ARRAY_SIZE(class_infos));
    return &class_infos[class];
 }

 const struct vk_format_class_info *
 vk_format_get_class_info(VkFormat format)
 {
     const struct vk_format_info *format_info = vk_format_get_info(format);
     return &class_infos[format_info->class];
 }
 """)

 def to_enum_name(prefix, name):
     return "%s" % prefix + re.sub('([^A-Za-z0-9_])', '_', name).upper()

 Format = namedtuple('Format', ['name', 'cls', 'ext', 'offset'])
 FormatClass = namedtuple('FormatClass', ['name', 'formats'])
 Extension = namedtuple('Extension', ['id', 'formats'])

 def get_formats(doc):
     """Extract the formats from the registry."""
     formats = {}

     for fmt in doc.findall('./formats/format'):
         xpath = './/enum[@name="{}"]'.format(fmt.attrib['name'])
         enum = doc.find(xpath)
         ext = None
         if 'extends' in enum.attrib:
             assert(enum.attrib['extends'] == 'VkFormat')
             if 'extnumber' in enum.attrib:
                 ext = int(enum.attrib['extnumber'])
             else:
                 xpath = xpath + '/..'
                 parent = doc.find(xpath)
                 while parent != None and ext == None:
                     if parent.tag == 'extension':
                         assert('number' in parent.attrib)
                         ext = parent.attrib['number']
                     xpath = xpath + '/..'
                     parent = doc.find(xpath)
             offset = int(enum.attrib['offset'])
         else:
             ext = 0
             offset = int(enum.attrib['value'])

         assert(ext != None)
         format = Format(fmt.attrib['name'], fmt.attrib['class'], ext, offset)
         formats[format.name] = format

     return formats

 def get_formats_from_xml(xml_files):
     formats = {}

     for filename in xml_files:
         doc = et.parse(filename)
         formats.update(get_formats(doc))

     return formats

 def main():
     parser = argparse.ArgumentParser()
     parser.add_argument('--out-c', required=True, help='Output C file.')
     parser.add_argument('--out-h', required=True, help='Output H file.')
     parser.add_argument('--xml',
                         help='Vulkan API XML file.',
                         required=True, action='append', dest='xml_files')
     args = parser.parse_args()

     formats = get_formats_from_xml(args.xml_files)
     classes = {}
     extensions = {}
     for n, f in formats.items():
         if f.cls not in classes:
             classes[f.cls] = FormatClass(f.cls, {})
         classes[f.cls].formats[f.name] = f
         if f.ext not in extensions:
             extensions[f.ext] = Extension(f.cls, {})
         extensions[f.ext].formats[f.name] = f

     assert os.path.dirname(args.out_c) == os.path.dirname(args.out_h)

     environment = {
         'header': os.path.basename(args.out_h),
         'formats': formats,
         'format_classes': classes,
         'extensions': extensions,
         'filename': os.path.basename(__file__),
         'to_enum_name': to_enum_name,
     }

     try:
         with open(args.out_h, 'w', encoding='utf-8') as f:
             guard = os.path.basename(args.out_h).replace('.', '_').upper()
             f.write(TEMPLATE_H.render(guard=guard, **environment))
         with open(args.out_c, 'w', encoding='utf-8') as f:
             f.write(TEMPLATE_C.render(**environment))
     except Exception:
         # In the event there's an error, this imports some helpers from mako
         # to print a useful stack trace and prints it, then exits with
         # status 1, if python is run with debug; otherwise it just raises
         # the exception
         import sys
         from mako import exceptions
         print(exceptions.text_error_template().render(), file=sys.stderr)
         sys.exit(1)

 if __name__ == '__main__':
     main()
	COPYRIGHT=u"""
	/* Copyright © 2022 Collabora, Ltd.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	* IN THE SOFTWARE.
	*/
	"""

	import argparse
	import os
	import re
	from collections import namedtuple
	import xml.etree.ElementTree as et

	from mako.template import Template

	TEMPLATE_H = Template(COPYRIGHT + """\
	/* This file generated from ${filename}, don't edit directly. */

	#ifndef VK_FORMAT_INFO_H
	#define VK_FORMAT_INFO_H

	#include <vulkan/vulkan_core.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	enum vk_format_class {
	MESA_VK_FORMAT_CLASS_UNKNOWN,
	% for name in format_classes:
	${to_enum_name('MESA_VK_FORMAT_CLASS_', name)},
	% endfor
	};

	struct vk_format_class_info {
	const VkFormat *formats;
	uint32_t format_count;
	};

	const struct vk_format_class_info *
	vk_format_class_get_info(enum vk_format_class class);

	const struct vk_format_class_info *
	vk_format_get_class_info(VkFormat format);

	#ifdef __cplusplus
	}
	#endif

	#endif
	""")

	TEMPLATE_C = Template(COPYRIGHT + """
	/* This file generated from ${filename}, don't edit directly. */

	#include "${header}"

	#include "util/macros.h"

	#include "vk_format.h"

	struct vk_format_info {
	enum vk_format_class class;
	};

	% for id, ext in extensions.items():
	static const struct vk_format_info ext${id}_format_infos[] = {
	% for name, format in ext.formats.items():
	[${format.offset}] = {
	.class = ${to_enum_name('MESA_VK_FORMAT_CLASS_', format.cls)},
	},
	% endfor
	};

	% endfor
	static const struct vk_format_info *
	vk_format_get_info(VkFormat format)
	{
	uint32_t extnumber =
	format < 1000000000 ? 0 : (((format % 1000000000) / 1000) + 1);
	uint32_t offset = format % 1000;

	switch (extnumber) {
	% for id, ext in extensions.items():
	case ${id}:
	assert(offset < ARRAY_SIZE(ext${id}_format_infos));
	return &ext${id}_format_infos[offset];
	% endfor
	default:
	unreachable("Invalid extension");
	}
	}

	% for clsname, cls in format_classes.items():
	% if len(cls.formats) > 0:
	static const VkFormat ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}[] = {
	% for fname in cls.formats:
	${fname},
	% endfor
	% endif
	};

	% endfor
	static const struct vk_format_class_info class_infos[] = {
	% for clsname, cls in format_classes.items():
	[${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname)}] = {
	% if len(cls.formats) > 0:
	.formats = ${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'},
	.format_count = ARRAY_SIZE(${to_enum_name('MESA_VK_FORMAT_CLASS_', clsname).lower() + '_formats'}),
	% else:
	0
	% endif
	},
	% endfor
	};

	const struct vk_format_class_info *
	vk_format_class_get_info(enum vk_format_class class)
	{
	assert(class < ARRAY_SIZE(class_infos));
	return &class_infos[class];
	}

	const struct vk_format_class_info *
	vk_format_get_class_info(VkFormat format)
	{
	const struct vk_format_info *format_info = vk_format_get_info(format);
	return &class_infos[format_info->class];
	}
	""")

	def to_enum_name(prefix, name):
	return "%s" % prefix + re.sub('([^A-Za-z0-9_])', '_', name).upper()

	Format = namedtuple('Format', ['name', 'cls', 'ext', 'offset'])
	FormatClass = namedtuple('FormatClass', ['name', 'formats'])
	Extension = namedtuple('Extension', ['id', 'formats'])

	def get_formats(doc):
	"""Extract the formats from the registry."""
	formats = {}

	for fmt in doc.findall('./formats/format'):
	xpath = './/enum[@name="{}"]'.format(fmt.attrib['name'])
	enum = doc.find(xpath)
	ext = None
	if 'extends' in enum.attrib:
	assert(enum.attrib['extends'] == 'VkFormat')
	if 'extnumber' in enum.attrib:
	ext = int(enum.attrib['extnumber'])
	else:
	xpath = xpath + '/..'
	parent = doc.find(xpath)
	while parent != None and ext == None:
	if parent.tag == 'extension':
	assert('number' in parent.attrib)
	ext = parent.attrib['number']
	xpath = xpath + '/..'
	parent = doc.find(xpath)
	offset = int(enum.attrib['offset'])
	else:
	ext = 0
	offset = int(enum.attrib['value'])

	assert(ext != None)
	format = Format(fmt.attrib['name'], fmt.attrib['class'], ext, offset)
	formats[format.name] = format

	return formats

	def get_formats_from_xml(xml_files):
	formats = {}

	for filename in xml_files:
	doc = et.parse(filename)
	formats.update(get_formats(doc))

	return formats

	def main():
	parser = argparse.ArgumentParser()
	parser.add_argument('--out-c', required=True, help='Output C file.')
	parser.add_argument('--out-h', required=True, help='Output H file.')
	parser.add_argument('--xml',
	help='Vulkan API XML file.',
	required=True, action='append', dest='xml_files')
	args = parser.parse_args()

	formats = get_formats_from_xml(args.xml_files)
	classes = {}
	extensions = {}
	for n, f in formats.items():
	if f.cls not in classes:
	classes[f.cls] = FormatClass(f.cls, {})
	classes[f.cls].formats[f.name] = f
	if f.ext not in extensions:
	extensions[f.ext] = Extension(f.cls, {})
	extensions[f.ext].formats[f.name] = f

	assert os.path.dirname(args.out_c) == os.path.dirname(args.out_h)

	environment = {
	'header': os.path.basename(args.out_h),
	'formats': formats,
	'format_classes': classes,
	'extensions': extensions,
	'filename': os.path.basename(__file__),
	'to_enum_name': to_enum_name,
	}

	try:
	with open(args.out_h, 'w', encoding='utf-8') as f:
	guard = os.path.basename(args.out_h).replace('.', '_').upper()
	f.write(TEMPLATE_H.render(guard=guard, **environment))
	with open(args.out_c, 'w', encoding='utf-8') as f:
	f.write(TEMPLATE_C.render(**environment))
	except Exception:
	# In the event there's an error, this imports some helpers from mako
	# to print a useful stack trace and prints it, then exits with
	# status 1, if python is run with debug; otherwise it just raises
	# the exception
	import sys
	from mako import exceptions
	print(exceptions.text_error_template().render(), file=sys.stderr)
	sys.exit(1)

	if __name__ == '__main__':
	main()