315 lines
11 KiB
Python
Executable File
315 lines
11 KiB
Python
Executable File
#!/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 parseTypedName(elem):
|
|
type = [nonestr(elem.text)]
|
|
name = None
|
|
for subelem in elem:
|
|
text = nonestr(subelem.text)
|
|
tail = nonestr(subelem.tail)
|
|
if subelem.tag == 'name':
|
|
name = text
|
|
break
|
|
else:
|
|
type.extend([text, tail])
|
|
return (''.join(type).strip(), name)
|
|
|
|
|
|
# Format a list of (type, name) tuples as a C-style parameter list
|
|
def fmtParams(params):
|
|
if not params:
|
|
return 'void'
|
|
return ', '.join(['%s %s' % (p[0], p[1]) for p in params])
|
|
|
|
# Format a list of (type, name) tuples as a C-style argument list
|
|
def fmtArgs(params):
|
|
return ', '.join(p[1] for p in params)
|
|
|
|
# Format a list of (type, name) tuples as comma-separated '"type", name'
|
|
def fmtTypeNameList(params):
|
|
return ', '.join(['"%s", %s' % (p[0], p[1]) for p in params])
|
|
|
|
|
|
def overrideSymbolName(sym):
|
|
# The wrapper intercepts glGetString and (sometimes) calls the generated
|
|
# __glGetString thunk which dispatches to the driver's glGetString
|
|
if sym == 'glGetString':
|
|
return '__glGetString'
|
|
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):
|
|
reg.OutputGenerator.genCmd(self, cmd, name)
|
|
|
|
rtype, fname = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(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), 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 trace.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):
|
|
reg.OutputGenerator.genCmd(self, cmd, name)
|
|
rtype, fname = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(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
|
|
|
|
# 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 traces.in
|
|
def writeTrace(self, outfile):
|
|
for cmd in self.cmds:
|
|
if cmd['rtype'] == 'void':
|
|
ret = '_VOID('
|
|
else:
|
|
ret = '(%s, ' % cmd['rtype']
|
|
|
|
params = cmd['params']
|
|
if len(params) > 0:
|
|
typeNameList = ', ' + fmtTypeNameList(params)
|
|
else:
|
|
typeNameList = ''
|
|
|
|
print('TRACE_GL%s%s, (%s), (%s), %d%s)'
|
|
% (ret, cmd['name'],
|
|
fmtParams(params), fmtArgs(params),
|
|
len(params), typeNameList),
|
|
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 = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(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)
|
|
|
|
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/trace.in', 'w') as f:
|
|
apigen.writeTrace(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')]
|
|
# 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)
|
|
|