def wrap_compile(functionName):
params = apiutil.Parameters(functionName)
return_type = apiutil.ReturnType(functionName)
# Make sure the return type is void. It's nonsensical to compile
# an element with any other return type.
if return_type != 'void':
print '/* Nonsense: DL function %s has a %s return type?!? */' % (
functionName, return_type)
# Define a structure to hold all the parameters. Note that the
# top parameters must exactly match the DLMInstanceList structure
# in include/cr_dlm.h, or everything will break horribly.
# Start off by getting all the pointer info we could ever use
# from the parameters
(pointers, pointername, pointerarg, pointertype, pointersize,
pointercomment) = GetPointerInfo(functionName)
# Finally, the compile wrapper. This one will diverge strongly
# depending on whether or not there are pointer parameters.
callstring = apiutil.MakeCallString(params)
argstring = apiutil.MakeDeclarationString(params)
props = apiutil.Properties(functionName)
if "useclient" in props or "pixelstore" in props:
callstring += ", c"
argstring += ", CRClientState *c"
print 'void DLM_APIENTRY crDLMCompile%s(%s)' % (functionName, argstring)
print '{'
print ' CRDLMContextState *state = CURRENT_STATE();'
print ' struct instance%s *instance;' % (functionName)
# The calling SPU is supposed to verify that the element is supposed to be
# compiled before it is actually compiled; typically, this is done based
# on whether a glNewList has been executed more recently than a glEndList.
# But some functions are dual-natured, sometimes being compiled, and sometimes
# being executed immediately. We can check for this here.
if "checklist" in apiutil.ChromiumProps(functionName):
print ' if (crDLMCheckList%s(%s))' % (
functionName, apiutil.MakeCallString(params))
print ' {'
print ' crdlm_error(__LINE__, __FILE__, GL_INVALID_OPERATION,'
print ' "this instance of function %s should not be compiled");' % functionName
print ' return;'
print ' }'
if len(pointers) > 1 or pointersize == 'special':
# Pass NULL, to just allocate space
print ' instance = crCalloc(sizeof(struct instance%s) + crdlm_pointers_%s(NULL, %s));' % (
functionName, functionName, callstring)
else:
print ' instance = crCalloc(sizeof(struct instance%s));' % (
functionName)
print ' if (!instance)'
print ' {'
print ' crdlm_error(__LINE__, __FILE__, GL_OUT_OF_MEMORY,'
print ' "out of memory adding %s to display list");' % (
functionName)
print ' return;'
print ' }'
# Put in the fields that must always exist
print ' instance->execute = execute%s;' % functionName
# Apply all the simple (i.e. non-pointer) parameters
for index in range(len(params)):
if index not in pointers:
name = params[index][0]
print ' instance->%s = %s;' % (name, name)
# We need to know instance size in bytes in order to save its state later.
print ' instance->cbInstance = sizeof(struct instance%s);' % functionName
# Set OPCODE.
print ' instance->iVBoxOpCode = VBOX_DL_OPCODE_%s;' % functionName
# If there's a pointer parameter, apply it.
if len(pointers) == 1:
print ' if (%s == NULL)' % (params[pointers[0]][0])
print ' instance->%s = NULL;' % (params[pointers[0]][0])
print ' else'
print ' instance->%s = instance->%s;' % (params[pointers[0]][0],
pointerarg)
if pointersize == 'special':
print ' instance->cbInstance += crdlm_pointers_%s(instance, %s);' % (
functionName, callstring)
else:
print ' crMemcpy((void *)instance->%s, (void *) %s, %s*sizeof(%s));' % (
params[pointers[0]][0], params[pointers[0]][0], pointersize,
pointertype)
elif len(pointers) == 2:
# this seems to work
print ' instance->cbInstance += crdlm_pointers_%s(instance, %s);' % (
functionName, callstring)
elif len(pointers) > 2:
print "#error don't know how to handle pointer parameters for %s" % (
functionName)
# Add the element to the current display list
AddInstanceToList(' ')
# If the element is a state-changing element, add it to the current state list
if apiutil.SetsTrackedState(functionName):
AddInstanceToStateList(' ')
print '}'
#include "packspu_proto.h"
/* This function is called through the dispatch table below when we hit a
* compiled CallList function. Essentially a recursive hack. */
static void PACKSPU_APIENTRY packspu_StateCallList( GLuint list )
{
crDLMReplayListState(list, &pack_spu.state_DT);
}
/* This function is called through the dispatch table below when we hit a
* compiled CallLists function. Essentially a recursive hack. */
static void PACKSPU_APIENTRY packspu_StateCallLists( GLsizei n, GLenum type, const GLvoid * lists )
{
crDLMReplayListsState(n, type, lists, &pack_spu.state_DT);
}
void packspuCreateStateTable( void )
{"""
keys = apiutil.GetDispatchedFunctions("../glapi_parser/APIspec.txt")
for func_name in keys:
# These functions are special to the state API
if func_name in ['CallList', 'CallLists']:
print '\tpack_spu.state_DT.%s = (%sFunc_t) packspu_State%s;' % (func_name, func_name, func_name)
elif apiutil.SetsTrackedState(func_name):
print '\tpack_spu.state_DT.%s = (%sFunc_t) crState%s;' % (func_name, func_name, func_name)
else:
print '\tpack_spu.state_DT.%s = NULL;' % (func_name)
print '}'
"""
pack_specials = []
keys = apiutil.GetDispatchedFunctions("../glapi_parser/APIspec.txt")
# make list of special functions
## VMGL: Because of state resume, a few more functions have specialized
## implementations by the new autogen script
for func_name in keys:
if ("get" in apiutil.Properties(func_name)
or apiutil.FindSpecial("packspu", func_name)
or apiutil.FindSpecial("packspu_flush", func_name)
or apiutil.FindSpecial("packspu_vertex", func_name)
or apiutil.CanCompile(func_name)
or apiutil.SetsTrackedState(func_name)):
pack_specials.append(func_name)
for func_name in keys:
if apiutil.FindSpecial("packspu_unimplemented", func_name):
continue
if func_name in pack_specials:
return_type = apiutil.ReturnType(func_name)
params = apiutil.Parameters(func_name)
print 'extern %s PACKSPU_APIENTRY packspu_%s( %s );' % (
return_type, func_name, apiutil.MakeDeclarationString(params))
print """
#endif
"""
print 'extern %s TILESORTSPU_APIENTRY tilesortspu_State%s( %s );' % (return_type, func_name, declarationString) continue # This dispatch table is used only for replaying display lists state. # It can safely have NULL entries in all the non-compilable or non-state functions. if not apiutil.CanCompile(func_name): if mode == 'table': print '\tt->%s = NULL;' % func_name elif mode == 'header': pass continue # The only entries left are those that manage tracked state. Everything # else gets a NULL. if not apiutil.SetsTrackedState(func_name): if mode == 'table': print '\tt->%s = NULL;' % func_name elif mode == 'header': pass else: if mode == 'table': print '\tt->%s = crState%s;' % (func_name, func_name) elif mode == 'header': pass # Done with the whole file. Print out any ending necessary. if mode == 'table': print '}' elif mode == 'header':
