29115d6b88
GLEW refresh (w.r.t opengl.org) Some GL API harmonization with apitrace. Add Regal support for GL_SGIX_ycrcb Further GL_REGAL_enable support for glEnable/glDisable of dispatch layers. DSA emulation moved to downstream of Regal::Emu::Iff Trace dispatch fixes for WGL Support for REGAL_TRACE_FILE setting, and JSON property. Tidy-up of Regal::Emu::Filt
249 lines
10 KiB
Python
249 lines
10 KiB
Python
#!/usr/bin/python
|
|
|
|
import re
|
|
|
|
# Class Type:
|
|
# regexc: regular expression for matching type expression.
|
|
# format: format for trace purpose.
|
|
# dim: num of dim, 0 is scalar. Default is 0.
|
|
# cast: casting of a type for trace purpose.
|
|
# baseType: base type for cgiReference type purpose.
|
|
# proxyType: proxy type for cgiEncode/cgiDecode purpose.
|
|
# default: default/initialization value for typedef.
|
|
|
|
class Type:
|
|
|
|
def __init__(self, regex, format = '', dim = 0, cast = None, baseType = None, proxyType = None, default = None):
|
|
|
|
self.regexc = re.compile(regex)
|
|
self.format = format
|
|
self.dim = dim
|
|
self.cast = cast
|
|
self.baseType = baseType
|
|
self.proxyType = proxyType
|
|
self.default = default
|
|
|
|
# Type regex expressions.
|
|
|
|
typeStdPat = '^\s*(const)*\s*(%s)\s*(const)*\s*$'
|
|
typePtrPat = '^\s*(const)*\s*(%s)\s*(const)*\s*\*\s*(const)*\s*$'
|
|
typeRefStdPat = typeStdPat % '(&)*\\s*(%s)'
|
|
typeRefPtrPat = typePtrPat % '(&)*\\s*(%s)'
|
|
|
|
# Basic Types
|
|
|
|
typesBasic = []
|
|
typesBasic.append(Type(typeStdPat % '(void)', None, dim =-1, baseType = None ))
|
|
typesBasic.append(Type(typePtrPat % '(void)', '%p', baseType = 'void' ))
|
|
typesBasic.append(Type(typePtrPat % '(void)\\s*(const)*\\s*\\*', None, dim = 1, baseType = 'void' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(signed)\\s*(char)', '%cs', baseType = 'signed char' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(unsigned)\\s*(char)', '%cu', baseType = 'unsigned char' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(char)', '%c', baseType = 'char' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(signed)*\\s*(short)\\s*(int)*', '%hd', baseType = 'short' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(signed)*\\s*(short)\\s*(int)*', '%hd', dim = 1, baseType = 'short' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(signed)*\\s*(long)\\s*(int)*', '%ld', baseType = 'long' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(signed)*\\s*(long)\\s*(int)*', '%ld', dim = 1, baseType = 'long' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(signed)*\\s*(long)\\s*(long)\\s*(int)*', '%lld', baseType = 'long long' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(signed)*\\s*(long)\\s*(long)\\s*(int)*', '%lld', dim = 1, baseType = 'long long' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(signed)*\\s*(int)', '%d', baseType = 'int' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(signed)*\\s*(int)', '%d', dim = 1, baseType = 'int' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(unsigned)\\s*(short)\\s*(int)*', '%hu', baseType = 'unsigned short' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(unsigned)\\s*(short)\\s*(int)*', '%hu', dim = 1, baseType = 'unsigned short' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(unsigned)\\s*(long)\\s*(int)*', '%lu', baseType = 'unsigned long' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(unsigned)\\s*(long)\\s*(int)*', '%lu', dim = 1, baseType = 'unsigned long' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(unsigned)*\\s*(long)\\s*(long)\\s*(int)*', '%lld', baseType = 'unsigned long long' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(unsigned)*\\s*(long)\\s*(long)\\s*(int)*', '%lld', dim = 1, baseType = 'unsigned long long' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(unsigned)\\s*(int)*', '%u', baseType = 'unsigned int' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(unsigned)\\s*(int)*', '%u', dim = 1, baseType = 'unsigned int' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(size_t)', '%zu', baseType = 'size_t' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(size_t)', '%zu', dim = 1, baseType = 'size_t' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(ptrdiff_t)', '%z', baseType = 'ptrdiff_t' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(ptrdiff_t)', '%z', dim = 1, baseType = 'ptrdiff_t' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(long)\\s*(double)', '%Lf', baseType = 'long double' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(long)\\s*(double)', '%Lf', dim = 1, baseType = 'long double' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(double)', '%lf', baseType = 'double' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(double)', '%lf', dim = 1, baseType = 'double' ))
|
|
typesBasic.append(Type(typeRefStdPat % '(float)', '%f', baseType = 'float' ))
|
|
typesBasic.append(Type(typeRefPtrPat % '(float)', '%f', dim = 1, baseType = 'float' ))
|
|
typesBasic.append(Type(typeStdPat % '(signed)\\s*(char)\\s*(const)*\\s*\\*', '%cs', dim = 1, baseType = 'signed char' ))
|
|
typesBasic.append(Type(typeStdPat % '(unsigned)\\s*(char)\\s*(const)*\\s*\\*', '%cu', dim = 1, baseType = 'unsigned char' ))
|
|
typesBasic.append(Type(typeStdPat % '(char)\\s*(const)*\\s*\\*', '%c', dim = 1, baseType = 'const char *' ))
|
|
typesBasic.append(Type(typePtrPat % '(char)\\s*(const)*\\s*\\*', '%s', dim = 1, baseType = 'const char * const *'))
|
|
|
|
# Find state for <typeName> using <states>.
|
|
# states := [ ('<type name>', '<state map name>'), ... ]
|
|
|
|
def findState(typeName, states = None):
|
|
|
|
for stateItem in states:
|
|
if stateItem[0].strip() == typeName.strip():
|
|
return stateItem[1].strip()
|
|
|
|
return None
|
|
|
|
# Generate Types from <enum> Enum.
|
|
|
|
def typesFromEnum(enum, states = None):
|
|
|
|
name = enum.name.strip()
|
|
|
|
enumStd = Type(typeRefStdPat % name, '%lu', baseType = name, default = enum.default)
|
|
enumPtr = Type(typeRefPtrPat % name, '%lu', dim = 1, baseType = name, default = enum.default)
|
|
|
|
# Find state and add state information to the new types.
|
|
|
|
if states:
|
|
stateValue = findState(enum.name, states)
|
|
if stateValue:
|
|
enumStd.state = stateValue
|
|
enumPtr.state = stateValue
|
|
|
|
enumTypes = []
|
|
enumTypes.append(enumStd)
|
|
enumTypes.append(enumPtr)
|
|
|
|
return enumTypes
|
|
|
|
# Generate Types from <typedef> Typedef.
|
|
|
|
def typesFromTypedef(typedef, types = typesBasic, states = None):
|
|
|
|
# Ignore function pointer types with no typeCast for now.
|
|
|
|
if len(typedef.function) and not hasattr(typedef, 'typeCast'):
|
|
return []
|
|
|
|
name = typedef.name.strip()
|
|
|
|
# Check for typeCast, baseType, proxyType, default attributes.
|
|
|
|
typeCast = getattr(typedef, 'typeCast', None)
|
|
if typeCast and not len(typeCast.strip()):
|
|
typeCast = None
|
|
|
|
baseType = getattr(typedef, 'baseType', None)
|
|
if not baseType or not len(baseType.strip()):
|
|
baseType = name
|
|
|
|
proxyType = getattr(typedef, 'proxyType', None)
|
|
if proxyType and not len(proxyType.strip()):
|
|
proxyType = None
|
|
|
|
typeDefault = getattr(typedef, 'default', None)
|
|
if typeDefault and not len(typeDefault.strip()):
|
|
typeDefault = None
|
|
|
|
# Match type using typeCast if typeCast present or using typedef value.
|
|
|
|
if typeCast:
|
|
typeMatchStd = typeCast
|
|
else:
|
|
typeMatchStd = typedef.type.strip()
|
|
typeMatchPtr = '%s *' % typeMatchStd
|
|
|
|
# Try to find a matching type using typeMatchStd.
|
|
|
|
typeStd = None
|
|
for aType in types:
|
|
if aType.regexc.match(typeMatchStd):
|
|
typeStd = Type(typeRefStdPat % name, aType.format, dim = aType.dim, cast = typeCast, baseType = baseType, proxyType = proxyType, default = typeDefault)
|
|
break
|
|
|
|
# Try to find a matching pointer type using typeMatchPtr.
|
|
|
|
typePtr = None
|
|
for aType in types:
|
|
if aType.regexc.match(typeMatchPtr):
|
|
typePtr = Type(typeRefPtrPat % name, aType.format, dim = aType.dim, cast = typeCast, baseType = baseType, proxyType = proxyType, default = typeDefault)
|
|
break
|
|
|
|
# Try to find a matching pointer type using typeStd with dim += 1.
|
|
|
|
if not typePtr and typeStd:
|
|
typePtr = Type(typeRefPtrPat % name, typeStd.format, dim = typeStd.dim + 1, cast = typeCast, baseType = baseType, proxyType = proxyType, default = typeDefault)
|
|
|
|
# Find state and add state information to the new types.
|
|
|
|
if states:
|
|
stateValue = findState(typedef.name, states)
|
|
if stateValue:
|
|
typeStd.state = stateValue
|
|
typePtr.state = stateValue
|
|
|
|
typedefTypes = []
|
|
if typeStd and typePtr:
|
|
typedefTypes.append(typeStd)
|
|
typedefTypes.append(typePtr)
|
|
|
|
return typedefTypes
|
|
|
|
# Generate types for each api.
|
|
|
|
def apiTypes(apis, states = None):
|
|
|
|
for api in apis:
|
|
|
|
# Initialize types to the basic types.
|
|
|
|
types = []
|
|
types.extend(typesBasic)
|
|
|
|
# Obtain state types as an attribute.
|
|
|
|
if not states:
|
|
states = getattr(api, 'states', None)
|
|
|
|
# Add enum types.
|
|
|
|
if api and api.enums:
|
|
for enum in api.enums:
|
|
types.extend(typesFromEnum(enum, states))
|
|
|
|
# Add typedef types.
|
|
|
|
if api and api.typedefs:
|
|
for typedef in api.typedefs:
|
|
types.extend(typesFromTypedef(typedef, types, states))
|
|
|
|
# Assign types as an attribute.
|
|
|
|
api.types = types
|
|
|
|
# Find type using <typeFormat> match with regex expressions for <types>.
|
|
|
|
def findType(typeFormat, types = typesBasic):
|
|
|
|
if typeFormat:
|
|
for aType in types:
|
|
if aType.regexc.match(typeFormat.strip()):
|
|
return aType
|
|
|
|
return None
|
|
|
|
# Strip typeFormat to the core type.
|
|
|
|
def typeStrip(typeFormat):
|
|
|
|
# Replace const, *, & with spaces.
|
|
pType = typeFormat.replace('const ', ' ').replace('&', ' ').replace('*', ' ')
|
|
if pType.endswith('const'):
|
|
pType = pType[:-5]
|
|
|
|
# Remove extraneous spaces.
|
|
pType = pType.replace(' ', ' ').strip()
|
|
|
|
return pType
|
|
|
|
# Return Type for parameter's type if it has state information.
|
|
|
|
def paramStateType(parameter, types = typesBasic):
|
|
|
|
aType = findType(parameter.type, types)
|
|
if not aType:
|
|
return None
|
|
|
|
lookup = getattr(parameter, 'lookup', None)
|
|
if lookup or hasattr(aType, 'state'):
|
|
return aType
|
|
|
|
return None
|