blob: 86fa28fb1fa819c3cfbffb85873e17488a13a303 [file] [log] [blame]
#!/usr/bin/env python
#
# Copyright 2014 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.
from __future__ import print_function
from operator import itemgetter
import collections
import os.path
import re
import sys
# Avoid endlessly adding to the path if this module is imported multiple
# times, e.g. in an interactive session
regpath = os.path.join(sys.path[0], "registry")
if sys.path[1] != regpath:
sys.path.insert(1, regpath)
import reg
AEP_EXTENSIONS = [
'GL_KHR_blend_equation_advanced',
'GL_KHR_debug',
'GL_KHR_texture_compression_astc_ldr',
'GL_OES_sample_shading',
'GL_OES_sample_variables',
'GL_OES_shader_image_atomic',
'GL_OES_shader_multisample_interpolation',
'GL_OES_texture_stencil8',
'GL_OES_texture_storage_multisample_2d_array',
'GL_EXT_copy_image',
'GL_EXT_draw_buffers_indexed',
'GL_EXT_geometry_shader',
'GL_EXT_gpu_shader5',
'GL_EXT_primitive_bounding_box',
'GL_EXT_shader_io_blocks',
'GL_EXT_tessellation_shader',
'GL_EXT_texture_border_clamp',
'GL_EXT_texture_buffer',
'GL_EXT_texture_cube_map_array',
'GL_EXT_texture_sRGB_decode']
def nonestr(s):
return s if s else ""
def parseProto(elem):
type = nonestr(elem.text)
name = None
for subelem in elem:
text = nonestr(subelem.text)
if subelem.tag == 'name':
name = text
else:
type += text
type += nonestr(subelem.tail)
return (type.strip(), name)
def parseParam(elem):
name = elem.find('name').text
declaration = ''.join(elem.itertext())
return (name, declaration)
# Format a list of (type, declaration) tuples as a C-style parameter list
def fmtParams(params):
if not params:
return 'void'
return ', '.join(p[1] for p in params)
# Format a list of (type, declaration) tuples as a C-style argument list
def fmtArgs(params):
return ', '.join(p[0] for p in params)
def overrideSymbolName(sym, apiname):
# The wrapper intercepts various glGet and glGetString functions and
# (sometimes) calls the generated thunk which dispatches to the
# driver's implementation
wrapped_get_syms = {
'gles1' : [
'glGetString'
],
'gles2' : [
'glGetString',
'glGetStringi',
'glGetBooleanv',
'glGetFloatv',
'glGetIntegerv',
'glGetInteger64v',
],
}
if sym in wrapped_get_syms.get(apiname):
return '__' + sym
else:
return sym
# Generate API trampoline templates:
# <rtype> API_ENTRY(<name>)(<params>) {
# CALL_GL_API(<name>, <args>);
# // or
# CALL_GL_API_RETURN(<name>, <args>);
# }
class TrampolineGen(reg.OutputGenerator):
def __init__(self):
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
def genCmd(self, cmd, name):
if re.search('Win32', name):
return
reg.OutputGenerator.genCmd(self, cmd, name)
rtype, fname = parseProto(cmd.elem.find('proto'))
params = [parseParam(p) for p in cmd.elem.findall('param')]
call = 'CALL_GL_API' if rtype == 'void' else 'CALL_GL_API_RETURN'
print('%s API_ENTRY(%s)(%s) {\n'
' %s(%s%s%s);\n'
'}'
% (rtype, overrideSymbolName(fname, self.genOpts.apiname),
fmtParams(params), call, fname,
', ' if len(params) > 0 else '',
fmtArgs(params)),
file=self.outFile)
# Collect all API prototypes across all families, remove duplicates,
# emit to entries.in and enums.in files.
class ApiGenerator(reg.OutputGenerator):
def __init__(self):
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
self.cmds = []
self.enums = collections.OrderedDict()
def genCmd(self, cmd, name):
if re.search('Win32', name):
return
reg.OutputGenerator.genCmd(self, cmd, name)
rtype, fname = parseProto(cmd.elem.find('proto'))
params = [parseParam(p) for p in cmd.elem.findall('param')]
self.cmds.append({'rtype': rtype, 'name': fname, 'params': params})
def genEnum(self, enuminfo, name):
reg.OutputGenerator.genEnum(self, enuminfo, name)
value = enuminfo.elem.get('value')
# Skip bitmask enums. Pattern matches:
# - GL_DEPTH_BUFFER_BIT
# - GL_MAP_INVALIDATE_BUFFER_BIT_EXT
# - GL_COLOR_BUFFER_BIT1_QCOM
# but not
# - GL_DEPTH_BITS
# - GL_QUERY_COUNTER_BITS_EXT
#
# TODO: Assuming a naming pattern and using a regex is what the
# old glenumsgen script did. But the registry XML knows which enums are
# parts of bitmask groups, so we should just use that. I'm not sure how
# to get the information out though, and it's not critical right now,
# so leaving for later.
if re.search('_BIT($|\d*_)', name):
return
if re.search('D3D|WIN32', name):
return
# Skip non-hex values (GL_TRUE, GL_FALSE, header guard junk)
if not re.search('0x[0-9A-Fa-f]+', value):
return
# Append 'u' or 'ull' type suffix if present
type = enuminfo.elem.get('type')
if type and type != 'i':
value += type
if value not in self.enums:
self.enums[value] = name
def finish(self):
# sort by function name, remove duplicates
self.cmds.sort(key=itemgetter('name'))
cmds = []
for cmd in self.cmds:
if len(cmds) == 0 or cmd != cmds[-1]:
cmds.append(cmd)
self.cmds = cmds
# Write entries.in
def writeEntries(self, outfile):
for cmd in self.cmds:
print('GL_ENTRY(%s, %s, %s)'
% (cmd['rtype'], cmd['name'], fmtParams(cmd['params'])),
file=outfile)
# Write enums.in
def writeEnums(self, outfile):
for enum in self.enums.iteritems():
print('GL_ENUM(%s,%s)' % (enum[0], enum[1]), file=outfile)
# Generate .spec entries for use by legacy 'gen' script
class SpecGenerator(reg.OutputGenerator):
def __init__(self):
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
def genCmd(self, cmd, name):
reg.OutputGenerator.genCmd(self, cmd, name)
rtype, fname = parseProto(cmd.elem.find('proto'))
params = [parseParam(p) for p in cmd.elem.findall('param')]
print('%s %s ( %s )' % (rtype, fname, fmtParams(params)),
file=self.outFile)
if __name__ == '__main__':
registry = reg.Registry()
registry.loadFile('registry/gl.xml')
registry.setGenerator(TrampolineGen())
TRAMPOLINE_OPTIONS = [
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common',
filename = '../../libs/GLES_CM/gl_api.in'),
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common',
emitversions = None,
defaultExtensions = 'gles1',
filename = '../../libs/GLES_CM/glext_api.in'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
filename = '../../libs/GLES2/gl2_api.in'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
emitversions = None,
defaultExtensions = 'gles2',
filename = '../../libs/GLES2/gl2ext_api.in')]
for opts in TRAMPOLINE_OPTIONS:
registry.apiGen(opts)
# Generate a GLESv1_CM entries separately to avoid extra driver loading time
apigen = ApiGenerator()
registry.setGenerator(apigen)
API_OPTIONS = [
# Generate non-extension versions of each API first, then extensions,
# so that if an extension enum was later standardized, we see the non-
# suffixed version first.
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common'),
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common',
emitversions = None,
defaultExtensions = 'gles1')]
for opts in API_OPTIONS:
registry.apiGen(opts)
apigen.finish()
with open('../../libs/entries_gles1.in', 'w') as f:
apigen.writeEntries(f)
apigen = ApiGenerator()
registry.setGenerator(apigen)
API_OPTIONS = [
# Generate non-extension versions of each API first, then extensions,
# so that if an extension enum was later standardized, we see the non-
# suffixed version first.
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common'),
reg.GeneratorOptions(
apiname = 'gles1',
profile = 'common',
emitversions = None,
defaultExtensions = 'gles1'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
emitversions = None,
defaultExtensions = 'gles2')]
for opts in API_OPTIONS:
registry.apiGen(opts)
apigen.finish()
with open('../../libs/entries.in', 'w') as f:
apigen.writeEntries(f)
with open('../../libs/enums.in', 'w') as f:
apigen.writeEnums(f)
registry.setGenerator(SpecGenerator())
SPEC_OPTIONS = [
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
versions = '3\.1',
filename = '../glgen/specs/gles11/GLES31.spec'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
emitversions = None,
defaultExtensions = None,
addExtensions = '^({})$'.format('|'.join(AEP_EXTENSIONS)),
filename = '../glgen/specs/gles11/GLES31Ext.spec'),
reg.GeneratorOptions(
apiname = 'gles2',
profile = 'common',
versions = '3\.2',
filename = '../glgen/specs/gles11/GLES32.spec')]
# SpecGenerator creates a good starting point, but the CFunc.java parser is
# so terrible that the .spec file needs a lot of manual massaging before
# it works. Commenting this out to avoid accidentally overwriting all the
# manual modifications.
#
# Eventually this script should generate the Java and JNI code directly,
# skipping the intermediate .spec step, and obsoleting the existing
# ../glgen system.
#
# for opts in SPEC_OPTIONS:
# registry.apiGen(opts)