summaryrefslogtreecommitdiff
path: root/src/mesa/es/main/apiutil.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/mesa/es/main/apiutil.py')
-rw-r--r--src/mesa/es/main/apiutil.py1117
1 files changed, 0 insertions, 1117 deletions
diff --git a/src/mesa/es/main/apiutil.py b/src/mesa/es/main/apiutil.py
deleted file mode 100644
index 7fb1afc3a8..0000000000
--- a/src/mesa/es/main/apiutil.py
+++ /dev/null
@@ -1,1117 +0,0 @@
-
-# apiutil.py
-#
-# This file defines a bunch of utility functions for OpenGL API code
-# generation.
-
-import sys, string, re
-
-
-#======================================================================
-
-def CopyrightC( ):
- print """/* Copyright (c) 2001, Stanford University
- All rights reserved.
-
- See the file LICENSE.txt for information on redistributing this software. */
- """
-
-def CopyrightDef( ):
- print """; Copyright (c) 2001, Stanford University
- ; All rights reserved.
- ;
- ; See the file LICENSE.txt for information on redistributing this software.
- """
-
-
-#======================================================================
-
-class APIFunction:
- """Class to represent a GL API function (name, return type,
- parameters, etc)."""
- def __init__(self):
- self.name = ''
- self.returnType = ''
- self.category = ''
- self.categories = []
- self.offset = -1
- self.alias = ''
- self.vectoralias = ''
- self.convertalias = ''
- self.aliasprefix = ''
- self.params = []
- self.paramlist = []
- self.paramvec = []
- self.paramaction = []
- self.paramprop = []
- self.paramset = []
- self.props = []
- self.chromium = []
-
-def FindParamIndex(params, paramName):
- """Given a function record, find the index of a named parameter"""
- for i in range (len(params)):
- if paramName == params[i][0]:
- return i
- # If we get here, there was no such parameter
- return None
-
-def SetTupleIndex(tuple, index, value):
- t = ()
- for i in range(len(tuple)):
- if i == index:
- t += (value,)
- else:
- t += (tuple[i],)
- return t
-
-def VersionSpecificValues(category, values):
- selectedValues = []
- for value in values:
- # Version-specific values are prefixed with the version
- # number, e.g. GLES1.0:GL_TEXTURE_CUBE_MAP_OES
- splitValue = value.split(":")
- if len(splitValue) == 2:
- if category != None and splitValue[0] != category:
- # Don't want this one.
- continue
- else:
- selectedValues.append(splitValue[1])
- else:
- selectedValues.append(value)
- return selectedValues
-
-def ProcessSpecFile(filename, userFunc, category = None):
- """Open the named API spec file and call userFunc(record, category) for each record
- processed."""
- specFile = open(filename, "r")
- if not specFile:
- print >>sys.stderr, "Error: couldn't open %s file!" % filename
- sys.exit()
-
- record = APIFunction()
-
- for line in specFile.readlines():
-
- # split line into tokens
- tokens = string.split(line)
-
- if len(tokens) > 0 and line[0] != '#':
-
- if tokens[0] == 'name':
- if record.name != '':
- # process the old function now
- userFunc(record, category)
- # reset the record
- record = APIFunction()
-
- record.name = tokens[1]
-
- elif tokens[0] == 'return':
- record.returnType = string.join(tokens[1:], ' ')
-
- elif tokens[0] == 'param':
- name = tokens[1]
- type = string.join(tokens[2:], ' ')
- vecSize = 0
- record.params.append((name, type, vecSize, None, [], None))
-
- elif tokens[0] == 'paramprop':
- name = tokens[1]
- str = tokens[2:]
- enums = []
- for i in range(len(str)):
- enums.append(str[i])
- record.paramprop.append((name, enums))
-
- elif tokens[0] == 'paramlist':
- name = tokens[1]
- str = tokens[2:]
- list = []
- for i in range(len(str)):
- list.append(str[i])
- record.paramlist.append((name,list))
-
- elif tokens[0] == 'paramvec':
- name = tokens[1]
- str = tokens[2:]
- vec = []
- for i in range(len(str)):
- vec.append(str[i])
- record.paramvec.append((name,vec))
-
- elif tokens[0] == 'paramset':
- line = tokens[1:]
- result = []
- for i in range(len(line)):
- tset = line[i]
- if tset == '[':
- nlist = []
- elif tset == ']':
- result.append(nlist)
- nlist = []
- else:
- nlist.append(tset)
- if result != []:
- record.paramset.append(result)
-
- elif tokens[0] == 'paramaction':
- name = tokens[1]
- str = tokens[2:]
- list = []
- for i in range(len(str)):
- list.append(str[i])
- record.paramaction.append((name,list))
-
- elif tokens[0] == 'category':
- record.category = tokens[1]
- record.categories = tokens[1:]
-
- elif tokens[0] == 'offset':
- if tokens[1] == '?':
- record.offset = -2
- else:
- record.offset = int(tokens[1])
-
- elif tokens[0] == 'alias':
- record.alias = tokens[1]
-
- elif tokens[0] == 'vectoralias':
- record.vectoralias = tokens[1]
-
- elif tokens[0] == 'convertalias':
- record.convertalias = tokens[1]
-
- elif tokens[0] == 'aliasprefix':
- record.aliasprefix = tokens[1]
-
- elif tokens[0] == 'props':
- record.props = tokens[1:]
-
- elif tokens[0] == 'chromium':
- record.chromium = tokens[1:]
-
- elif tokens[0] == 'vector':
- vecName = tokens[1]
- vecSize = int(tokens[2])
- index = FindParamIndex(record.params, vecName)
- if index == None:
- print >>sys.stderr, "Can't find vector '%s' for function '%s'" % (vecName, record.name)
- # Adjust just the vector size
- record.params[index] = SetTupleIndex(record.params[index], 2, vecSize)
-
- elif tokens[0] == 'dependentvector':
- dependentVecName = tokens[1]
- # the dependentVecSize may be an int
- # expression
- dependentVecSize = tokens[2]
- controllingParam = tokens[3]
- controllingParamIndex = FindParamIndex(record.params, controllingParam)
- if controllingParamIndex == None:
- print >>sys.stderr, "Can't find controlling param '%s' for function '%s'" % (controllingParam, record.name)
- controllingValues = tokens[4:]
-
- # Remember that all of the controllingValues
- # are valid values for the controllingParam.
- # We may be duplicating controllingValues
- # here (i.e. if we get them from different
- # places); we'll sort them out later.
- validValues = record.params[controllingParamIndex][4]
- for value in VersionSpecificValues(category, controllingValues):
- validValues.append((value, dependentVecSize, dependentVecName, [], None, None))
- # Don't need to reassign validValues back
- # to the tuple - it's a shallow pointer,
- # so the tuple is already modified.
- # (And attempting to do so would produce an
- # error anyway.)
-
- elif tokens[0] == "dependentnovalueconvert":
- paramName = tokens[1]
- controllingParamName = tokens[2]
- controllingValues = tokens[3:]
-
- controllingParamIndex = FindParamIndex(record.params, controllingParamName)
- if controllingParamIndex == None:
- print >>sys.stderr, "Can't find controlling param '%s' for function '%s'" % (controllingParamName, record.name)
-
- validValues = record.params[controllingParamIndex][4]
- for value in VersionSpecificValues(category, controllingValues):
- validValues.append((value, None, None, [], None, "noconvert"))
-
-
-
- elif tokens[0] == 'checkparam':
- paramName = tokens[1]
- values = tokens[2:]
- paramIndex = FindParamIndex(record.params, paramName)
- if paramIndex == None:
- print >>sys.stderr, "Can't find checked param '%s' for function '%s'" % (paramName, record.name)
-
- errorCode = None
-
- # We may be duplicating valid values here;
- # just add all values to the existing
- # record, and we'll prune out duplicates
- # later
- validValues = record.params[paramIndex][4]
-
- # A /GL_* value represents an error, not
- # a real value. Look through the values
- # and only append the non-error values.
- for v in VersionSpecificValues(category, values):
- if v[0] == "/":
- errorCode = v[1:]
- else:
- validValues.append((v, None, None, [], errorCode, None))
- # Don't need to reassign validValues back
- # to the parameter tuple - it's a shallow pointer,
- # so the tuple is already modified.
- # (And attempting to do so would produce an
- # error anyway.)
-
- elif tokens[0] == 'checkdependentparam':
- paramName = tokens[1]
- controllingValue = tokens[2]
- dependentParamName = tokens[3]
- validDependentValues = tokens[4:]
- errorCode = None
-
- # A /GL_* value represents an error, not
- # a real value. Look through the values
- # and only append the non-error values.
- validDependentValues = []
- for v in tokens[4:]:
- if v[0] == "/":
- errorCode = v[1:]
- else:
- validDependentValues.append(v)
-
- paramIndex = FindParamIndex(record.params, paramName)
- if paramIndex == None:
- print >>sys.stderr, "Can't find dependent param '%s' for function '%s'" % (paramName, record.name)
-
- validValues = record.params[paramIndex][4]
- # We may be duplicating valid values here;
- # we'll sort them out later. Avoid
- # adding a controlling value record
- # at all if there are no values
- # in the list of values (so that
- # controlling values with only
- # version-specific values listed
- # end up as version-specific
- # themselves).
- versionSpecificValues = VersionSpecificValues(category, validDependentValues)
- if versionSpecificValues != []:
- validValues.append((controllingValue, None, dependentParamName, versionSpecificValues, errorCode, None))
- # Don't need to reassign validValues back
- # to the tuple - it's a shallow pointer,
- # so the tuple is already modified.
- # (And attempting to do so would produce an
- # error anyway.)
-
- elif tokens[0] == 'convertparams':
- convertToType = tokens[1]
- # Replace the conversion type in each named
- # parameter
- for paramName in tokens[2:]:
- paramIndex = FindParamIndex(record.params, paramName)
- if paramIndex == None:
- print >>sys.stderr, "Can't find converted param '%s' for function '%s'" % (paramName, record.name)
- # Tuples don't support item assignment,
- # so to replace scalar values in a
- # tuple, you have to reassign the
- # whole friggin' thing.
- record.params[paramIndex] = SetTupleIndex(record.params[paramIndex], 3, convertToType)
-
- else:
- print >>sys.stderr, 'Invalid token %s after function %s' % (tokens[0], record.name)
- #endif
- #endif
- #endfor
-
- # Call the user function for the last record, if we still have one
- # lying around nearly finished
- if record.name != '':
- # process the function now
- userFunc(record, category)
- specFile.close()
-#enddef
-
-
-# Dictionary [name] of APIFunction:
-__FunctionDict = {}
-
-# Dictionary [name] of name
-__VectorVersion = {}
-
-# Reverse mapping of function name aliases
-__ReverseAliases = {}
-
-def CheckCategories(category, categories):
- for c in categories:
- if category == c.split(":")[0]:
- return 1
-
- return 0
-
-def AddFunction(record, category):
- # If there is a category, we only want records from that category.
- # Note that a category may be in the form "GLES1.1:OES_extension_name",
- # which means that the function is supported as an extension in
- # GLES1.1...
- if category and not CheckCategories(category, record.categories):
- return
-
- # Don't allow duplicates
- if __FunctionDict.has_key(record.name):
- print >>sys.stderr, "Duplicate record name '%s' ignored" % record.name
- return
-
- # Clean up a bit. We collected valid values for parameters
- # on the fly; it's quite possible that there are duplicates.
- # If there are, collect them together.
- #
- # We're also going to keep track of all the dependent values
- # that can show up for a parameter; the number of GLenum values
- # (identified with a prefixed "GL_") affects how parameter
- # value conversion happens, as GLenum values are not scaled
- # when converted to or from GLfixed values, the way integer
- # and floating point values are.
- paramValueConversion = {}
-
- for i in range(len(record.params)):
- foundValidValues = {}
-
- (name, type, maxVecSize, convertToType, validValues, valueConversion) = record.params[i]
- for (controllingValue, vecSize, dependentParamName, dependentValues, errorCode, valueConvert) in validValues:
- # Keep track of the maximum vector size for the
- # *dependent* parameter, not for the controlling
- # parameter. Note that the dependent parameter
- # may be an expression - in this case, don't
- # consider it.
- if dependentParamName != None and vecSize != None and vecSize.isdigit():
- dependentParamIndex = FindParamIndex(record.params, dependentParamName)
- if dependentParamIndex == None:
- print >>sys.stderr, "Couldn't find dependent parameter '%s' of function '%s'" % (dependentParamName, record.name)
- (dName, dType, dMaxVecSize, dConvert, dValid, dValueConversion) = record.params[dependentParamIndex]
- if dMaxVecSize == None or int(vecSize) > dMaxVecSize:
- dMaxVecSize = int(vecSize)
- record.params[dependentParamIndex] = (dName, dType, dMaxVecSize, dConvert, dValid, dValueConversion)
-
- # Make sure an entry for the controlling value
- # exists in the foundValidValues dictionary
- if controllingValue in foundValidValues:
- # The value was already there. Merge the
- # two together, giving errors if needed.
- (oldControllingValue, oldVecSize, oldDependentParamName, oldDependentValues, oldErrorCode, oldValueConvert) = foundValidValues[controllingValue]
-
- # Make sure the vector sizes are compatible;
- # either one should be None (and be
- # overridden by the other), or they should
- # match exactly. If one is not an
- # integer (this can happen if the
- # dependent value is an integer expression,
- # which occurs a couple of times), don't
- # use it.
- if oldVecSize == None:
- oldVecSize = vecSize
- elif vecSize != None and vecSize != oldVecSize:
- print >>sys.stderr, "Found two different vector sizes (%s and %s) for the same controlling value '%s' of the same parameter '%s' of function '%s'" % (oldVecSize, vecSize, controllingValue, name, record.name)
-
- # Same for the dependent parameter name.
- if oldDependentParamName == None:
- oldDependentParamName = dependentParamName
- elif dependentParamName != None and dependentParamName != oldDependentParamName:
- print >>sys.stderr, "Found two different dependent parameter names (%s and %s) for the same controlling value '%s' of the same parameter '%s' of function '%s'" % (oldDependentParamName, dependentParamName, controllingValue, name, record.name)
-
- # And for the error code.
- if oldErrorCode == None:
- oldErrorCode = errorCode
- elif errorCode != None and errorCode != oldErrorCode:
- print >>sys.stderr, "Found two different error codes(%s and %s) for the same controlling value '%s' of the same parameter '%s' of function '%s'" % (oldErrorCode, errorCode, controllingValue, name, record.name)
-
- # And for the value conversion flag
- if oldValueConvert == None:
- oldValueConvert = valueConvert
- elif valueConvert != None and valueConvert != oldValueConvert:
- print >>sys.stderr, "Found two different value conversions(%s and %s) for the same controlling value '%s' of the same parameter '%s' of function '%s'" % (oldValueConvert, valueConvert, controllingValue, name, record.name)
-
- # Combine the dependentValues together
- # directly, but uniquely
- for value in dependentValues:
- if value not in oldDependentValues:
- oldDependentValues.append(value)
-
- # Stick the combined value back into the
- # dictionary. We'll sort it back to the
- # array later.
- foundValidValues[oldControllingValue] = (oldControllingValue, oldVecSize, oldDependentParamName, oldDependentValues, oldErrorCode, oldValueConvert)
- else: # new controlling value
- # Just add it to the dictionary so we don't
- # add the same value more than once.
- foundValidValues[controllingValue] = (controllingValue, vecSize, dependentParamName, dependentValues, errorCode, valueConvert)
- # endif a new controlling value
-
- # endfor all valid values for this parameter
-
- # Now the foundValidValues[] dictionary holds all the
- # pruned values (at most one for each valid value).
- # But the validValues[] array still holds the order,
- # which we want to maintain. Go through the validValues
- # array just for the names of the controlling values;
- # add any uncopied values to the prunedValidValues array.
- prunedValidValues = []
-
- for (controllingValue, vecSize, dependentParamName, dependentValues, errorCode, valueConvert) in validValues:
- if controllingValue in foundValidValues:
- prunedValidValues.append(foundValidValues[controllingValue])
- # Delete it from the dictionary so it isn't
- # copied again.
- del foundValidValues[controllingValue]
-
- # Each parameter that is being converted may have a
- # subset of values that are GLenums and are never
- # converted. In some cases, the parameter will
- # be implicitly determined to be such, by examining
- # the listed possible values and determining for
- # any particular controlling value whether there are
- # any GLenum-valued allowed values.
- #
- # In other cases, the parameter will be explicitly
- # marked as such with the "dependentnovalueconvert" flag;
- # this is the way it has to be done with queries (which
- # cannot list a valid list of values to be passed,
- # because values are returned, not passed).
- #
- # For each value of controlling GLenum, we'll also
- # need to know whether its dependent values are
- # always converted (none of its values require
- # GLenums to be passed in dependent parameters),
- # never converted (all of its values require GLenums),
- # or sometimes converted.
- numNoConvertValues = 0
- allDependentParams = []
- for j in range(len(prunedValidValues)):
- (controllingValue, vecSize, dependentParamName, dependentValues, errorCode, valueConvert) = prunedValidValues[j]
- if dependentParamName != None and dependentParamName not in allDependentParams:
- allDependentParams.append(dependentParamName)
-
- # Check for an explicit noconvert marking...
- if valueConvert == "noconvert":
- numNoConvertValues += 1
- else:
- # Or check for an implicit one.
- for value in dependentValues:
- if value[0:3] == "GL_":
- valueConvert = "noconvert"
- prunedValidValues[j] = (controllingValue, vecSize, dependentParamName, dependentValues, errorCode, valueConvert)
- numNoConvertValues += 1
- break
-
- # For each named dependent param, set the value conversion
- # flag based on whether all values, none, or some need
- # value conversion. This value is set stepwise
- # for each parameter examined -
- for dp in allDependentParams:
- if numNoConvertValues == 0:
- if not paramValueConversion.has_key(dp):
- paramValueConversion[dp] = "all"
- elif paramValueConversion[dp] == "none":
- paramValueConversion[dp] = "some"
- elif numNoConvertValues == len(prunedValidValues):
- if not paramValueConversion.has_key(dp):
- paramValueConversion[dp] = "none"
- elif paramValueConversion[dp] == "all":
- paramValueConversion[dp] = "some"
- else:
- paramValueConversion[dp] = "some"
-
- # Save away the record. Save a placeholder in the
- # valueConversion field - we can't set that until we've
- # examined all the parameters.
- record.params[i] = (name, type, maxVecSize, convertToType, prunedValidValues, None)
-
- # endfor each param of the passed-in function record
-
- # One more pass: for each parameter, if it is a parameter that
- # needs conversion, save its value conversion type ("all", "none",
- # or "some"). We only have to worry about conditional value
- # conversion for GLfixed parameters; in all other cases, we
- # either don't convert at all (for non-converting parameters) or
- # we convert everything.
- for i in range(len(record.params)):
- (name, type, maxVecSize, convertToType, validValues, valueConversion) = record.params[i]
- if convertToType == None:
- valueConversion = None
- elif paramValueConversion.has_key(name):
- valueConversion = paramValueConversion[name]
- else:
- valueConversion = "all"
-
- record.params[i] = (name, type, maxVecSize, convertToType, validValues, valueConversion)
-
- # We're done cleaning up!
- # Add the function to the permanent record and we're done.
- __FunctionDict[record.name] = record
-
-
-def GetFunctionDict(specFile = "", category = None):
- if not specFile:
- specFile = "../glapi_parser/APIspec.txt"
- if len(__FunctionDict) == 0:
- ProcessSpecFile(specFile, AddFunction, category)
- # Look for vector aliased functions
- for func in __FunctionDict.keys():
- va = __FunctionDict[func].vectoralias
- if va != '':
- __VectorVersion[va] = func
- #endif
-
- # and look for regular aliases (for glloader)
- a = __FunctionDict[func].alias
- if a:
- __ReverseAliases[a] = func
- #endif
- #endfor
- #endif
- return __FunctionDict
-
-
-def GetAllFunctions(specFile = "", category = None):
- """Return sorted list of all functions known to Chromium."""
- d = GetFunctionDict(specFile, category)
- funcs = []
- for func in d.keys():
- rec = d[func]
- if not "omit" in rec.chromium:
- funcs.append(func)
- funcs.sort()
- return funcs
-
-
-def GetDispatchedFunctions(specFile = "", category = None):
- """Return sorted list of all functions handled by SPU dispatch table."""
- d = GetFunctionDict(specFile, category)
- funcs = []
- for func in d.keys():
- rec = d[func]
- if (not "omit" in rec.chromium and
- not "stub" in rec.chromium and
- rec.alias == ''):
- funcs.append(func)
- funcs.sort()
- return funcs
-
-#======================================================================
-
-def ReturnType(funcName):
- """Return the C return type of named function.
- Examples: "void" or "const GLubyte *". """
- d = GetFunctionDict()
- return d[funcName].returnType
-
-
-def Parameters(funcName):
- """Return list of tuples (name, type, vecSize) of function parameters.
- Example: if funcName=="ClipPlane" return
- [ ("plane", "GLenum", 0), ("equation", "const GLdouble *", 4) ] """
- d = GetFunctionDict()
- return d[funcName].params
-
-def ParamAction(funcName):
- """Return list of names of actions for testing.
- For PackerTest only."""
- d = GetFunctionDict()
- return d[funcName].paramaction
-
-def ParamList(funcName):
- """Return list of tuples (name, list of values) of function parameters.
- For PackerTest only."""
- d = GetFunctionDict()
- return d[funcName].paramlist
-
-def ParamVec(funcName):
- """Return list of tuples (name, vector of values) of function parameters.
- For PackerTest only."""
- d = GetFunctionDict()
- return d[funcName].paramvec
-
-def ParamSet(funcName):
- """Return list of tuples (name, list of values) of function parameters.
- For PackerTest only."""
- d = GetFunctionDict()
- return d[funcName].paramset
-
-
-def Properties(funcName):
- """Return list of properties of the named GL function."""
- d = GetFunctionDict()
- return d[funcName].props
-
-def AllWithProperty(property):
- """Return list of functions that have the named property."""
- funcs = []
- for funcName in GetDispatchedFunctions():
- if property in Properties(funcName):
- funcs.append(funcName)
- return funcs
-
-def Category(funcName):
- """Return the primary category of the named GL function."""
- d = GetFunctionDict()
- return d[funcName].category
-
-def Categories(funcName):
- """Return all the categories of the named GL function."""
- d = GetFunctionDict()
- return d[funcName].categories
-
-def ChromiumProps(funcName):
- """Return list of Chromium-specific properties of the named GL function."""
- d = GetFunctionDict()
- return d[funcName].chromium
-
-def ParamProps(funcName):
- """Return list of Parameter-specific properties of the named GL function."""
- d = GetFunctionDict()
- return d[funcName].paramprop
-
-def Alias(funcName):
- """Return the function that the named function is an alias of.
- Ex: Alias('DrawArraysEXT') = 'DrawArrays'.
- """
- d = GetFunctionDict()
- return d[funcName].alias
-
-def AliasPrefix(funcName):
- """Return the function that the named function is an alias of.
- Ex: Alias('DrawArraysEXT') = 'DrawArrays'.
- """
- d = GetFunctionDict()
- if d[funcName].aliasprefix == '':
- return "_mesa_"
- else:
- return d[funcName].aliasprefix
-
-def ReverseAlias(funcName):
- """Like Alias(), but the inverse."""
- d = GetFunctionDict()
- if funcName in __ReverseAliases.keys():
- return __ReverseAliases[funcName]
- else:
- return ''
-
-def NonVectorFunction(funcName):
- """Return the non-vector version of the given function, or ''.
- For example: NonVectorFunction("Color3fv") = "Color3f"."""
- d = GetFunctionDict()
- return d[funcName].vectoralias
-
-def ConversionFunction(funcName):
- """Return a function that can be used to implement the
- given function, using different types.
- For example: ConvertedFunction("Color4x") = "Color4f"."""
- d = GetFunctionDict()
- return d[funcName].convertalias
-
-def VectorFunction(funcName):
- """Return the vector version of the given non-vector-valued function,
- or ''.
- For example: VectorVersion("Color3f") = "Color3fv"."""
- d = GetFunctionDict()
- if funcName in __VectorVersion.keys():
- return __VectorVersion[funcName]
- else:
- return ''
-
-def GetCategoryWrapper(func_name):
- """Return a C preprocessor token to test in order to wrap code.
- This handles extensions.
- Example: GetTestWrapper("glActiveTextureARB") = "CR_multitexture"
- Example: GetTestWrapper("glBegin") = ""
- """
- cat = Category(func_name)
- if (cat == "1.0" or
- cat == "1.1" or
- cat == "1.2" or
- cat == "Chromium" or
- cat == "GL_chromium"):
- return ''
- elif cat[0] =='1':
- # i.e. OpenGL 1.3 or 1.4 or 1.5
- return "OPENGL_VERSION_" + string.replace(cat, ".", "_")
- else:
- assert cat != ''
- return string.replace(cat, "GL_", "")
-
-
-def CanCompile(funcName):
- """Return 1 if the function can be compiled into display lists, else 0."""
- props = Properties(funcName)
- if ("nolist" in props or
- "get" in props or
- "setclient" in props):
- return 0
- else:
- return 1
-
-def HasChromiumProperty(funcName, propertyList):
- """Return 1 if the function or any alias has any property in the
- propertyList"""
- for funcAlias in [funcName, NonVectorFunction(funcName), VectorFunction(funcName)]:
- if funcAlias:
- props = ChromiumProps(funcAlias)
- for p in propertyList:
- if p in props:
- return 1
- return 0
-
-def CanPack(funcName):
- """Return 1 if the function can be packed, else 0."""
- return HasChromiumProperty(funcName, ['pack', 'extpack', 'expandpack'])
-
-def HasPackOpcode(funcName):
- """Return 1 if the function has a true pack opcode"""
- return HasChromiumProperty(funcName, ['pack', 'extpack'])
-
-def SetsState(funcName):
- """Return 1 if the function sets server-side state, else 0."""
- props = Properties(funcName)
-
- # Exceptions. The first set of these functions *do* have
- # server-side state-changing effects, but will be missed
- # by the general query, because they either render (e.g.
- # Bitmap) or do not compile into display lists (e.g. all the others).
- #
- # The second set do *not* have server-side state-changing
- # effects, despite the fact that they do not render
- # and can be compiled. They are control functions
- # that are not trackable via state.
- if funcName in ['Bitmap', 'DeleteTextures', 'FeedbackBuffer',
- 'RenderMode', 'BindBufferARB', 'DeleteFencesNV']:
- return 1
- elif funcName in ['ExecuteProgramNV']:
- return 0
-
- # All compilable functions that do not render and that do
- # not set or use client-side state (e.g. DrawArrays, et al.), set
- # server-side state.
- if CanCompile(funcName) and "render" not in props and "useclient" not in props and "setclient" not in props:
- return 1
-
- # All others don't set server-side state.
- return 0
-
-def SetsClientState(funcName):
- """Return 1 if the function sets client-side state, else 0."""
- props = Properties(funcName)
- if "setclient" in props:
- return 1
- return 0
-
-def SetsTrackedState(funcName):
- """Return 1 if the function sets state that is tracked by
- the state tracker, else 0."""
- # These functions set state, but aren't tracked by the state
- # tracker for various reasons:
- # - because the state tracker doesn't manage display lists
- # (e.g. CallList and CallLists)
- # - because the client doesn't have information about what
- # the server supports, so the function has to go to the
- # server (e.g. CompressedTexImage calls)
- # - because they require a round-trip to the server (e.g.
- # the CopyTexImage calls, SetFenceNV, TrackMatrixNV)
- if funcName in [
- 'CopyTexImage1D', 'CopyTexImage2D',
- 'CopyTexSubImage1D', 'CopyTexSubImage2D', 'CopyTexSubImage3D',
- 'CallList', 'CallLists',
- 'CompressedTexImage1DARB', 'CompressedTexSubImage1DARB',
- 'CompressedTexImage2DARB', 'CompressedTexSubImage2DARB',
- 'CompressedTexImage3DARB', 'CompressedTexSubImage3DARB',
- 'SetFenceNV'
- ]:
- return 0
-
- # Anything else that affects client-side state is trackable.
- if SetsClientState(funcName):
- return 1
-
- # Anything else that doesn't set state at all is certainly
- # not trackable.
- if not SetsState(funcName):
- return 0
-
- # Per-vertex state isn't tracked the way other state is
- # tracked, so it is specifically excluded.
- if "pervertex" in Properties(funcName):
- return 0
-
- # Everything else is fine
- return 1
-
-def UsesClientState(funcName):
- """Return 1 if the function uses client-side state, else 0."""
- props = Properties(funcName)
- if "pixelstore" in props or "useclient" in props:
- return 1
- return 0
-
-def IsQuery(funcName):
- """Return 1 if the function returns information to the user, else 0."""
- props = Properties(funcName)
- if "get" in props:
- return 1
- return 0
-
-def FuncGetsState(funcName):
- """Return 1 if the function gets GL state, else 0."""
- d = GetFunctionDict()
- props = Properties(funcName)
- if "get" in props:
- return 1
- else:
- return 0
-
-def IsPointer(dataType):
- """Determine if the datatype is a pointer. Return 1 or 0."""
- if string.find(dataType, "*") == -1:
- return 0
- else:
- return 1
-
-
-def PointerType(pointerType):
- """Return the type of a pointer.
- Ex: PointerType('const GLubyte *') = 'GLubyte'
- """
- t = string.split(pointerType, ' ')
- if t[0] == "const":
- t[0] = t[1]
- return t[0]
-
-
-
-
-def OpcodeName(funcName):
- """Return the C token for the opcode for the given function."""
- return "CR_" + string.upper(funcName) + "_OPCODE"
-
-
-def ExtendedOpcodeName(funcName):
- """Return the C token for the extended opcode for the given function."""
- return "CR_" + string.upper(funcName) + "_EXTEND_OPCODE"
-
-
-
-
-#======================================================================
-
-def MakeCallString(params):
- """Given a list of (name, type, vectorSize) parameters, make a C-style
- formal parameter string.
- Ex return: 'index, x, y, z'.
- """
- result = ''
- i = 1
- n = len(params)
- for (name, type, vecSize, convertToType, validValues, valueConversion) in params:
- result += name
- if i < n:
- result = result + ', '
- i += 1
- #endfor
- return result
-#enddef
-
-
-def MakeDeclarationString(params):
- """Given a list of (name, type, vectorSize) parameters, make a C-style
- parameter declaration string.
- Ex return: 'GLuint index, GLfloat x, GLfloat y, GLfloat z'.
- """
- n = len(params)
- if n == 0:
- return 'void'
- else:
- result = ''
- i = 1
- for (name, type, vecSize, convertToType, validValues, valueConversion) in params:
- result = result + type + ' ' + name
- if i < n:
- result = result + ', '
- i += 1
- #endfor
- return result
- #endif
-#enddef
-
-
-def MakePrototypeString(params):
- """Given a list of (name, type, vectorSize) parameters, make a C-style
- parameter prototype string (types only).
- Ex return: 'GLuint, GLfloat, GLfloat, GLfloat'.
- """
- n = len(params)
- if n == 0:
- return 'void'
- else:
- result = ''
- i = 1
- for (name, type, vecSize, convertToType, validValues, valueConversion) in params:
- result = result + type
- # see if we need a comma separator
- if i < n:
- result = result + ', '
- i += 1
- #endfor
- return result
- #endif
-#enddef
-
-
-#======================================================================
-
-__lengths = {
- 'GLbyte': 1,
- 'GLubyte': 1,
- 'GLshort': 2,
- 'GLushort': 2,
- 'GLint': 4,
- 'GLuint': 4,
- 'GLfloat': 4,
- 'GLclampf': 4,
- 'GLdouble': 8,
- 'GLclampd': 8,
- 'GLenum': 4,
- 'GLboolean': 1,
- 'GLsizei': 4,
- 'GLbitfield': 4,
- 'void': 0, # XXX why?
- 'int': 4,
- 'GLintptrARB': 4, # XXX or 8 bytes?
- 'GLsizeiptrARB': 4 # XXX or 8 bytes?
-}
-
-def sizeof(type):
- """Return size of C datatype, in bytes."""
- if not type in __lengths.keys():
- print >>sys.stderr, "%s not in lengths!" % type
- return __lengths[type]
-
-
-#======================================================================
-align_types = 1
-
-def FixAlignment( pos, alignment ):
- # if we want double-alignment take word-alignment instead,
- # yes, this is super-lame, but we know what we are doing
- if alignment > 4:
- alignment = 4
- if align_types and alignment and ( pos % alignment ):
- pos += alignment - ( pos % alignment )
- return pos
-
-def WordAlign( pos ):
- return FixAlignment( pos, 4 )
-
-def PointerSize():
- return 8 # Leave room for a 64 bit pointer
-
-def PacketLength( params ):
- len = 0
- for (name, type, vecSize, convertToType, validValues, valueConversion) in params:
- if IsPointer(type):
- size = PointerSize()
- else:
- assert string.find(type, "const") == -1
- size = sizeof(type)
- len = FixAlignment( len, size ) + size
- len = WordAlign( len )
- return len
-
-#======================================================================
-
-__specials = {}
-
-def LoadSpecials( filename ):
- table = {}
- try:
- f = open( filename, "r" )
- except:
- __specials[filename] = {}
- print >>sys.stderr, "%s not present" % filename
- return {}
-
- for line in f.readlines():
- line = string.strip(line)
- if line == "" or line[0] == '#':
- continue
- table[line] = 1
-
- __specials[filename] = table
- return table
-
-
-def FindSpecial( filename, glName ):
- table = {}
- try:
- table = __specials[filename]
- except KeyError:
- table = LoadSpecials( filename )
-
- try:
- if (table[glName] == 1):
- return 1
- else:
- return 0 #should never happen
- except KeyError:
- return 0
-
-
-def AllSpecials( table_file ):
- table = {}
- filename = table_file + "_special"
- try:
- table = __specials[filename]
- except KeyError:
- table = LoadSpecials( filename )
-
- keys = table.keys()
- keys.sort()
- return keys
-
-
-def AllSpecials( table_file ):
- filename = table_file + "_special"
- table = {}
- try:
- table = __specials[filename]
- except KeyError:
- table = LoadSpecials(filename)
-
- ret = table.keys()
- ret.sort()
- return ret
-
-
-def NumSpecials( table_file ):
- filename = table_file + "_special"
- table = {}
- try:
- table = __specials[filename]
- except KeyError:
- table = LoadSpecials(filename)
- return len(table.keys())
-
-def PrintRecord(record):
- argList = MakeDeclarationString(record.params)
- if record.category == "Chromium":
- prefix = "cr"
- else:
- prefix = "gl"
- print '%s %s%s(%s);' % (record.returnType, prefix, record.name, argList )
- if len(record.props) > 0:
- print ' /* %s */' % string.join(record.props, ' ')
-
-#ProcessSpecFile("APIspec.txt", PrintRecord)
-
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-05 15:14:22 +0000