-#!/usr/bin/env python
-
-# Mesa 3-D graphics library
-# Version: 7.9
-#
-# Copyright (C) 2010 LunarG Inc.
-#
-# 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 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.
-#
-# Authors:
-# Chia-I Wu <olv@lunarg.com>
-
-import sys
-# make it possible to import glapi
-import os
-GLAPI = os.path.join(".", os.path.dirname(sys.argv[0]), "../glapi/gen")
-sys.path.append(GLAPI)
-
-import re
-from optparse import OptionParser
-import gl_XML
-import glX_XML
-
-
-# number of dynamic entries
-ABI_NUM_DYNAMIC_ENTRIES = 256
-
-class ABIEntry(object):
- """Represent an ABI entry."""
-
- _match_c_param = re.compile(
- '^(?P<type>[\w\s*]+?)(?P<name>\w+)(\[(?P<array>\d+)\])?$')
-
- def __init__(self, cols, attrs, xml_data = None):
- self._parse(cols)
-
- self.slot = attrs['slot']
- self.hidden = attrs['hidden']
- self.alias = attrs['alias']
- self.handcode = attrs['handcode']
- self.xml_data = xml_data
-
- def c_prototype(self):
- return '%s %s(%s)' % (self.c_return(), self.name, self.c_params())
-
- def c_return(self):
- ret = self.ret
- if not ret:
- ret = 'void'
-
- return ret
-
- def c_params(self):
- """Return the parameter list used in the entry prototype."""
- c_params = []
- for t, n, a in self.params:
- sep = '' if t.endswith('*') else ' '
- arr = '[%d]' % a if a else ''
- c_params.append(t + sep + n + arr)
- if not c_params:
- c_params.append('void')
-
- return ", ".join(c_params)
-
- def c_args(self):
- """Return the argument list used in the entry invocation."""
- c_args = []
- for t, n, a in self.params:
- c_args.append(n)
-
- return ", ".join(c_args)
-
- def _parse(self, cols):
- ret = cols.pop(0)
- if ret == 'void':
- ret = None
-
- name = cols.pop(0)
-
- params = []
- if not cols:
- raise Exception(cols)
- elif len(cols) == 1 and cols[0] == 'void':
- pass
- else:
- for val in cols:
- params.append(self._parse_param(val))
-
- self.ret = ret
- self.name = name
- self.params = params
-
- def _parse_param(self, c_param):
- m = self._match_c_param.match(c_param)
- if not m:
- raise Exception('unrecognized param ' + c_param)
-
- c_type = m.group('type').strip()
- c_name = m.group('name')
- c_array = m.group('array')
- c_array = int(c_array) if c_array else 0
-
- return (c_type, c_name, c_array)
-
- def __str__(self):
- return self.c_prototype()
-
- def __cmp__(self, other):
- # compare slot, alias, and then name
- res = cmp(self.slot, other.slot)
- if not res:
- if not self.alias:
- res = -1
- elif not other.alias:
- res = 1
-
- if not res:
- res = cmp(self.name, other.name)
-
- return res
-
-def abi_parse_xml(xml):
- """Parse a GLAPI XML file for ABI entries."""
- api = gl_XML.parse_GL_API(xml, glX_XML.glx_item_factory())
-
- entry_dict = {}
- for func in api.functionIterateByOffset():
- # make sure func.name appear first
- entry_points = func.entry_points[:]
- entry_points.remove(func.name)
- entry_points.insert(0, func.name)
-
- for name in entry_points:
- attrs = {
- 'slot': func.offset,
- 'hidden': not func.is_static_entry_point(name),
- 'alias': None if name == func.name else func.name,
- 'handcode': bool(func.has_different_protocol(name)),
- }
-
- # post-process attrs
- if attrs['alias']:
- try:
- alias = entry_dict[attrs['alias']]
- except KeyError:
- raise Exception('failed to alias %s' % attrs['alias'])
- if alias.alias:
- raise Exception('recursive alias %s' % ent.name)
- attrs['alias'] = alias
- if attrs['handcode']:
- attrs['handcode'] = func.static_glx_name(name)
- else:
- attrs['handcode'] = None
-
- if entry_dict.has_key(name):
- raise Exception('%s is duplicated' % (name))
-
- cols = []
- cols.append(func.return_type)
- cols.append(name)
- params = func.get_parameter_string(name)
- cols.extend([p.strip() for p in params.split(',')])
-
- ent = ABIEntry(cols, attrs, func)
- entry_dict[ent.name] = ent
-
- entries = entry_dict.values()
- entries.sort()
-
- return entries
-
-def abi_parse_line(line):
- cols = [col.strip() for col in line.split(',')]
-
- attrs = {
- 'slot': -1,
- 'hidden': False,
- 'alias': None,
- 'handcode': None,
- }
-
- # extract attributes from the first column
- vals = cols[0].split(':')
- while len(vals) > 1:
- val = vals.pop(0)
- if val.startswith('slot='):
- attrs['slot'] = int(val[5:])
- elif val == 'hidden':
- attrs['hidden'] = True
- elif val.startswith('alias='):
- attrs['alias'] = val[6:]
- elif val.startswith('handcode='):
- attrs['handcode'] = val[9:]
- elif not val:
- pass
- else:
- raise Exception('unknown attribute %s' % val)
- cols[0] = vals[0]
-
- return (attrs, cols)
-
-def abi_parse(filename):
- """Parse a CSV file for ABI entries."""
- fp = open(filename) if filename != '-' else sys.stdin
- lines = [line.strip() for line in fp.readlines()
- if not line.startswith('#') and line.strip()]
-
- entry_dict = {}
- next_slot = 0
- for line in lines:
- attrs, cols = abi_parse_line(line)
-
- # post-process attributes
- if attrs['alias']:
- try:
- alias = entry_dict[attrs['alias']]
- except KeyError:
- raise Exception('failed to alias %s' % attrs['alias'])
- if alias.alias:
- raise Exception('recursive alias %s' % ent.name)
- slot = alias.slot
- attrs['alias'] = alias
- else:
- slot = next_slot
- next_slot += 1
-
- if attrs['slot'] < 0:
- attrs['slot'] = slot
- elif attrs['slot'] != slot:
- raise Exception('invalid slot in %s' % (line))
-
- ent = ABIEntry(cols, attrs)
- if entry_dict.has_key(ent.name):
- raise Exception('%s is duplicated' % (ent.name))
- entry_dict[ent.name] = ent
-
- entries = entry_dict.values()
- entries.sort()
-
- return entries
-
-def abi_sanity_check(entries):
- if not entries:
- return
-
- all_names = []
- last_slot = entries[-1].slot
- i = 0
- for slot in xrange(last_slot + 1):
- if entries[i].slot != slot:
- raise Exception('entries are not ordered by slots')
- if entries[i].alias:
- raise Exception('first entry of slot %d aliases %s'
- % (slot, entries[i].alias.name))
- handcode = None
- while i < len(entries) and entries[i].slot == slot:
- ent = entries[i]
- if not handcode and ent.handcode:
- handcode = ent.handcode
- elif ent.handcode != handcode:
- raise Exception('two aliases with handcode %s != %s',
- ent.handcode, handcode)
-
- if ent.name in all_names:
- raise Exception('%s is duplicated' % (ent.name))
- if ent.alias and ent.alias.name not in all_names:
- raise Exception('failed to alias %s' % (ent.alias.name))
- all_names.append(ent.name)
- i += 1
- if i < len(entries):
- raise Exception('there are %d invalid entries' % (len(entries) - 1))
-
-class ABIPrinter(object):
- """MAPI Printer"""
-
- def __init__(self, entries):
- self.entries = entries
-
- # sort entries by their names
- self.entries_sorted_by_names = self.entries[:]
- self.entries_sorted_by_names.sort(lambda x, y: cmp(x.name, y.name))
-
- self.indent = ' ' * 3
- self.noop_warn = 'noop_warn'
- self.noop_generic = 'noop_generic'
- self.current_get = 'entry_current_get'
-
- self.api_defines = []
- self.api_headers = ['"KHR/khrplatform.h"']
- self.api_call = 'KHRONOS_APICALL'
- self.api_entry = 'KHRONOS_APIENTRY'
- self.api_attrs = 'KHRONOS_APIATTRIBUTES'
-
- self.c_header = ''
-
- self.lib_need_table_size = True
- self.lib_need_noop_array = True
- self.lib_need_stubs = True
- self.lib_need_all_entries = True
- self.lib_need_non_hidden_entries = False
-
- def c_notice(self):
- return '/* This file is automatically generated by mapi_abi.py. Do not modify. */'
-
- def c_public_includes(self):
- """Return includes of the client API headers."""
- defines = ['#define ' + d for d in self.api_defines]
- includes = ['#include ' + h for h in self.api_headers]
- return "\n".join(defines + includes)
-
- def need_entry_point(self, ent):
- """Return True if an entry point is needed for the entry."""
- # non-handcode hidden aliases may share the entry they alias
- use_alias = (ent.hidden and ent.alias and not ent.handcode)
- return not use_alias
-
- def c_public_declarations(self, prefix):
- """Return the declarations of public entry points."""
- decls = []
- for ent in self.entries:
- if not self.need_entry_point(ent):
- continue
- export = self.api_call if not ent.hidden else ''
- decls.append(self._c_decl(ent, prefix, True, export) + ';')
-
- return "\n".join(decls)
-
- def c_mapi_table(self):
- """Return defines of the dispatch table size."""
- num_static_entries = self.entries[-1].slot + 1
- return ('#define MAPI_TABLE_NUM_STATIC %d\n' + \
- '#define MAPI_TABLE_NUM_DYNAMIC %d') % (
- num_static_entries, ABI_NUM_DYNAMIC_ENTRIES)
-
- def c_mapi_table_initializer(self, prefix):
- """Return the array initializer for mapi_table_fill."""
- entries = [self._c_function(ent, prefix)
- for ent in self.entries if not ent.alias]
- pre = self.indent + '(mapi_proc) '
- return pre + (',\n' + pre).join(entries)
-
- def c_mapi_table_spec(self):
- """Return the spec for mapi_init."""
- specv1 = []
- line = '"1'
- for ent in self.entries:
- if not ent.alias:
- line += '\\0"\n'
- specv1.append(line)
- line = '"'
- line += '%s\\0' % ent.name
- line += '";'
- specv1.append(line)
-
- return self.indent + self.indent.join(specv1)
-
- def _c_function(self, ent, prefix, mangle=False, stringify=False):
- """Return the function name of an entry."""
- formats = {
- True: { True: '%s_STR(%s)', False: '%s(%s)' },
- False: { True: '"%s%s"', False: '%s%s' },
- }
- fmt = formats[prefix.isupper()][stringify]
- name = ent.name
- if mangle and ent.hidden:
- name = '_dispatch_stub_' + str(ent.slot)
- return fmt % (prefix, name)
-
- def _c_function_call(self, ent, prefix):
- """Return the function name used for calling."""
- if ent.handcode:
- # _c_function does not handle this case
- formats = { True: '%s(%s)', False: '%s%s' }
- fmt = formats[prefix.isupper()]
- name = fmt % (prefix, ent.handcode)
- elif self.need_entry_point(ent):
- name = self._c_function(ent, prefix, True)
- else:
- name = self._c_function(ent.alias, prefix, True)
- return name
-
- def _c_decl(self, ent, prefix, mangle=False, export=''):
- """Return the C declaration for the entry."""
- decl = '%s %s %s(%s)' % (ent.c_return(), self.api_entry,
- self._c_function(ent, prefix, mangle), ent.c_params())
- if export:
- decl = export + ' ' + decl
- if self.api_attrs:
- decl += ' ' + self.api_attrs
-
- return decl
-
- def _c_cast(self, ent):
- """Return the C cast for the entry."""
- cast = '%s (%s *)(%s)' % (
- ent.c_return(), self.api_entry, ent.c_params())
-
- return cast
-
- def c_private_declarations(self, prefix):
- """Return the declarations of private functions."""
- decls = [self._c_decl(ent, prefix) + ';'
- for ent in self.entries if not ent.alias]
-
- return "\n".join(decls)
-
- def c_public_dispatches(self, prefix, no_hidden):
- """Return the public dispatch functions."""
- dispatches = []
- for ent in self.entries:
- if ent.hidden and no_hidden:
- continue
-
- if not self.need_entry_point(ent):
- continue
-
- export = self.api_call if not ent.hidden else ''
-
- proto = self._c_decl(ent, prefix, True, export)
- cast = self._c_cast(ent)
-
- ret = ''
- if ent.ret:
- ret = 'return '
- stmt1 = self.indent
- stmt1 += 'const struct mapi_table *_tbl = %s();' % (
- self.current_get)
- stmt2 = self.indent
- stmt2 += 'mapi_func _func = ((const mapi_func *) _tbl)[%d];' % (
- ent.slot)
- stmt3 = self.indent
- stmt3 += '%s((%s) _func)(%s);' % (ret, cast, ent.c_args())
-
- disp = '%s\n{\n%s\n%s\n%s\n}' % (proto, stmt1, stmt2, stmt3)
-
- if ent.handcode:
- disp = '#if 0\n' + disp + '\n#endif'
-
- dispatches.append(disp)
-
- return '\n\n'.join(dispatches)
-
- def c_public_initializer(self, prefix):
- """Return the initializer for public dispatch functions."""
- names = []
- for ent in self.entries:
- if ent.alias:
- continue
-
- name = '%s(mapi_func) %s' % (self.indent,
- self._c_function_call(ent, prefix))
- names.append(name)
-
- return ',\n'.join(names)
-
- def c_stub_string_pool(self):
- """Return the string pool for use by stubs."""
- # sort entries by their names
- sorted_entries = self.entries[:]
- sorted_entries.sort(lambda x, y: cmp(x.name, y.name))
-
- pool = []
- offsets = {}
- count = 0
- for ent in sorted_entries:
- offsets[ent] = count
- pool.append('%s' % (ent.name))
- count += len(ent.name) + 1
-
- pool_str = self.indent + '"' + \
- ('\\0"\n' + self.indent + '"').join(pool) + '";'
- return (pool_str, offsets)
-
- def c_stub_initializer(self, prefix, pool_offsets):
- """Return the initializer for struct mapi_stub array."""
- stubs = []
- for ent in self.entries_sorted_by_names:
- stubs.append('%s{ (void *) %d, %d, NULL }' % (
- self.indent, pool_offsets[ent], ent.slot))
-
- return ',\n'.join(stubs)
-
- def c_noop_functions(self, prefix, warn_prefix):
- """Return the noop functions."""
- noops = []
- for ent in self.entries:
- if ent.alias:
- continue
-
- proto = self._c_decl(ent, prefix, False, 'static')
-
- stmt1 = self.indent;
- space = ''
- for t, n, a in ent.params:
- stmt1 += "%s(void) %s;" % (space, n)
- space = ' '
-
- if ent.params:
- stmt1 += '\n';
-
- stmt1 += self.indent + '%s(%s);' % (self.noop_warn,
- self._c_function(ent, warn_prefix, False, True))
-
- if ent.ret:
- stmt2 = self.indent + 'return (%s) 0;' % (ent.ret)
- noop = '%s\n{\n%s\n%s\n}' % (proto, stmt1, stmt2)
- else:
- noop = '%s\n{\n%s\n}' % (proto, stmt1)
-
- noops.append(noop)
-
- return '\n\n'.join(noops)
-
- def c_noop_initializer(self, prefix, use_generic):
- """Return an initializer for the noop dispatch table."""
- entries = [self._c_function(ent, prefix)
- for ent in self.entries if not ent.alias]
- if use_generic:
- entries = [self.noop_generic] * len(entries)
-
- entries.extend([self.noop_generic] * ABI_NUM_DYNAMIC_ENTRIES)
-
- pre = self.indent + '(mapi_func) '
- return pre + (',\n' + pre).join(entries)
-
- def c_asm_gcc(self, prefix, no_hidden):
- asm = []
-
- for ent in self.entries:
- if ent.hidden and no_hidden:
- continue
-
- if not self.need_entry_point(ent):
- continue
-
- name = self._c_function(ent, prefix, True, True)
-
- if ent.handcode:
- asm.append('#if 0')
-
- if ent.hidden:
- asm.append('".hidden "%s"\\n"' % (name))
-
- if ent.alias and not (ent.alias.hidden and no_hidden):
- asm.append('".globl "%s"\\n"' % (name))
- asm.append('".set "%s", "%s"\\n"' % (name,
- self._c_function(ent.alias, prefix, True, True)))
- else:
- asm.append('STUB_ASM_ENTRY(%s)"\\n"' % (name))
- asm.append('"\\t"STUB_ASM_CODE("%d")"\\n"' % (ent.slot))
-
- if ent.handcode:
- asm.append('#endif')
- asm.append('')
-
- return "\n".join(asm)
-
- def output_for_lib(self):
- print self.c_notice()
-
- if self.c_header:
- print
- print self.c_header
-
- print
- print '#ifdef MAPI_TMP_DEFINES'
- print self.c_public_includes()
- print
- print self.c_public_declarations(self.prefix_lib)
- print '#undef MAPI_TMP_DEFINES'
- print '#endif /* MAPI_TMP_DEFINES */'
-
- if self.lib_need_table_size:
- print
- print '#ifdef MAPI_TMP_TABLE'
- print self.c_mapi_table()
- print '#undef MAPI_TMP_TABLE'
- print '#endif /* MAPI_TMP_TABLE */'
-
- if self.lib_need_noop_array:
- print
- print '#ifdef MAPI_TMP_NOOP_ARRAY'
- print '#ifdef DEBUG'
- print
- print self.c_noop_functions(self.prefix_noop, self.prefix_warn)
- print
- print 'const mapi_func table_%s_array[] = {' % (self.prefix_noop)
- print self.c_noop_initializer(self.prefix_noop, False)
- print '};'
- print
- print '#else /* DEBUG */'
- print
- print 'const mapi_func table_%s_array[] = {' % (self.prefix_noop)
- print self.c_noop_initializer(self.prefix_noop, True)
- print '};'
- print
- print '#endif /* DEBUG */'
- print '#undef MAPI_TMP_NOOP_ARRAY'
- print '#endif /* MAPI_TMP_NOOP_ARRAY */'
-
- if self.lib_need_stubs:
- pool, pool_offsets = self.c_stub_string_pool()
- print
- print '#ifdef MAPI_TMP_PUBLIC_STUBS'
- print 'static const char public_string_pool[] ='
- print pool
- print
- print 'static const struct mapi_stub public_stubs[] = {'
- print self.c_stub_initializer(self.prefix_lib, pool_offsets)
- print '};'
- print '#undef MAPI_TMP_PUBLIC_STUBS'
- print '#endif /* MAPI_TMP_PUBLIC_STUBS */'
-
- if self.lib_need_all_entries:
- print
- print '#ifdef MAPI_TMP_PUBLIC_ENTRIES'
- print self.c_public_dispatches(self.prefix_lib, False)
- print
- print 'static const mapi_func public_entries[] = {'
- print self.c_public_initializer(self.prefix_lib)
- print '};'
- print '#undef MAPI_TMP_PUBLIC_ENTRIES'
- print '#endif /* MAPI_TMP_PUBLIC_ENTRIES */'
-
- print
- print '#ifdef MAPI_TMP_STUB_ASM_GCC'
- print '__asm__('
- print self.c_asm_gcc(self.prefix_lib, False)
- print ');'
- print '#undef MAPI_TMP_STUB_ASM_GCC'
- print '#endif /* MAPI_TMP_STUB_ASM_GCC */'
-
- if self.lib_need_non_hidden_entries:
- all_hidden = True
- for ent in self.entries:
- if not ent.hidden:
- all_hidden = False
- break
- if not all_hidden:
- print
- print '#ifdef MAPI_TMP_PUBLIC_ENTRIES_NO_HIDDEN'
- print self.c_public_dispatches(self.prefix_lib, True)
- print
- print '/* does not need public_entries */'
- print '#undef MAPI_TMP_PUBLIC_ENTRIES_NO_HIDDEN'
- print '#endif /* MAPI_TMP_PUBLIC_ENTRIES_NO_HIDDEN */'
-
- print
- print '#ifdef MAPI_TMP_STUB_ASM_GCC_NO_HIDDEN'
- print '__asm__('
- print self.c_asm_gcc(self.prefix_lib, True)
- print ');'
- print '#undef MAPI_TMP_STUB_ASM_GCC_NO_HIDDEN'
- print '#endif /* MAPI_TMP_STUB_ASM_GCC_NO_HIDDEN */'
-
- def output_for_app(self):
- print self.c_notice()
- print
- print self.c_private_declarations(self.prefix_app)
- print
- print '#ifdef API_TMP_DEFINE_SPEC'
- print
- print 'static const char %s_spec[] =' % (self.prefix_app)
- print self.c_mapi_table_spec()
- print
- print 'static const mapi_proc %s_procs[] = {' % (self.prefix_app)
- print self.c_mapi_table_initializer(self.prefix_app)
- print '};'
- print
- print '#endif /* API_TMP_DEFINE_SPEC */'
-
-class GLAPIPrinter(ABIPrinter):
- """OpenGL API Printer"""
-
- def __init__(self, entries):
- for ent in entries:
- self._override_for_api(ent)
- super(GLAPIPrinter, self).__init__(entries)
-
- self.api_defines = ['GL_GLEXT_PROTOTYPES']
- self.api_headers = ['"GL/gl.h"', '"GL/glext.h"']
- self.api_call = 'GLAPI'
- self.api_entry = 'APIENTRY'
- self.api_attrs = ''
-
- self.lib_need_table_size = False
- self.lib_need_noop_array = False
- self.lib_need_stubs = False
- self.lib_need_all_entries = False
- self.lib_need_non_hidden_entries = True
-
- self.prefix_lib = 'GLAPI_PREFIX'
- self.prefix_app = '_mesa_'
- self.prefix_noop = 'noop'
- self.prefix_warn = self.prefix_lib
-
- self.c_header = self._get_c_header()
-
- def _override_for_api(self, ent):
- """Override attributes of an entry if necessary for this
- printer."""
- # By default, no override is necessary.
- pass
-
- def _get_c_header(self):
- header = """#ifndef _GLAPI_TMP_H_
-#define _GLAPI_TMP_H_
-#ifdef USE_MGL_NAMESPACE
-#define GLAPI_PREFIX(func) mgl##func
-#define GLAPI_PREFIX_STR(func) "mgl"#func
-#else
-#define GLAPI_PREFIX(func) gl##func
-#define GLAPI_PREFIX_STR(func) "gl"#func
-#endif /* USE_MGL_NAMESPACE */
-
-typedef int GLfixed;
-typedef int GLclampx;
-#endif /* _GLAPI_TMP_H_ */"""
-
- return header
-
-class ES1APIPrinter(GLAPIPrinter):
- """OpenGL ES 1.x API Printer"""
-
- def __init__(self, entries):
- super(ES1APIPrinter, self).__init__(entries)
- self.prefix_lib = 'gl'
- self.prefix_warn = 'gl'
-
- def _override_for_api(self, ent):
- if ent.xml_data is None:
- raise Exception('ES2 API printer requires XML input')
- ent.hidden = ent.name not in \
- ent.xml_data.entry_points_for_api_version('es1')
- ent.handcode = False
-
- def _get_c_header(self):
- header = """#ifndef _GLAPI_TMP_H_
-#define _GLAPI_TMP_H_
-typedef int GLfixed;
-typedef int GLclampx;
-#endif /* _GLAPI_TMP_H_ */"""
-
- return header
-
-class ES2APIPrinter(GLAPIPrinter):
- """OpenGL ES 2.x API Printer"""
-
- def __init__(self, entries):
- super(ES2APIPrinter, self).__init__(entries)
- self.prefix_lib = 'gl'
- self.prefix_warn = 'gl'
-
- def _override_for_api(self, ent):
- if ent.xml_data is None:
- raise Exception('ES2 API printer requires XML input')
- ent.hidden = ent.name not in \
- ent.xml_data.entry_points_for_api_version('es2')
- ent.handcode = False
-
- def _get_c_header(self):
- header = """#ifndef _GLAPI_TMP_H_
-#define _GLAPI_TMP_H_
-typedef int GLfixed;
-typedef int GLclampx;
-#endif /* _GLAPI_TMP_H_ */"""
-
- return header
-
-class SharedGLAPIPrinter(GLAPIPrinter):
- """Shared GLAPI API Printer"""
-
- def __init__(self, entries):
- super(SharedGLAPIPrinter, self).__init__(entries)
-
- self.lib_need_table_size = True
- self.lib_need_noop_array = True
- self.lib_need_stubs = True
- self.lib_need_all_entries = True
- self.lib_need_non_hidden_entries = False
-
- self.prefix_lib = 'shared'
- self.prefix_warn = 'gl'
-
- def _override_for_api(self, ent):
- ent.hidden = True
- ent.handcode = False
-
- def _get_c_header(self):
- header = """#ifndef _GLAPI_TMP_H_
-#define _GLAPI_TMP_H_
-typedef int GLfixed;
-typedef int GLclampx;
-#endif /* _GLAPI_TMP_H_ */"""
-
- return header
-
-class VGAPIPrinter(ABIPrinter):
- """OpenVG API Printer"""
-
- def __init__(self, entries):
- super(VGAPIPrinter, self).__init__(entries)
-
- self.api_defines = ['VG_VGEXT_PROTOTYPES']
- self.api_headers = ['"VG/openvg.h"', '"VG/vgext.h"']
- self.api_call = 'VG_API_CALL'
- self.api_entry = 'VG_API_ENTRY'
- self.api_attrs = 'VG_API_EXIT'
-
- self.prefix_lib = 'vg'
- self.prefix_app = 'vega'
- self.prefix_noop = 'noop'
- self.prefix_warn = 'vg'
-
-def parse_args():
- printers = ['vgapi', 'glapi', 'es1api', 'es2api', 'shared-glapi']
- modes = ['lib', 'app']
-
- parser = OptionParser(usage='usage: %prog [options] <filename>')
- parser.add_option('-p', '--printer', dest='printer',
- help='printer to use: %s' % (", ".join(printers)))
- parser.add_option('-m', '--mode', dest='mode',
- help='target user: %s' % (", ".join(modes)))
-
- options, args = parser.parse_args()
- if not args or options.printer not in printers or \
- options.mode not in modes:
- parser.print_help()
- sys.exit(1)
-
- return (args[0], options)
-
-def main():
- printers = {
- 'vgapi': VGAPIPrinter,
- 'glapi': GLAPIPrinter,
- 'es1api': ES1APIPrinter,
- 'es2api': ES2APIPrinter,
- 'shared-glapi': SharedGLAPIPrinter,
- }
-
- filename, options = parse_args()
-
- if filename.endswith('.xml'):
- entries = abi_parse_xml(filename)
- else:
- entries = abi_parse(filename)
- abi_sanity_check(entries)
-
- printer = printers[options.printer](entries)
- if options.mode == 'lib':
- printer.output_for_lib()
- else:
- printer.output_for_app()
-
-if __name__ == '__main__':
- main()