def MakeNormalCall(return_type, func_name, params, counter_init=0): counter = counter_init copy_of_params = params[:] for i in range(0, len(params)): (name, type, vecSize) = params[i] if apiutil.IsPointer(copy_of_params[i][1]): params[i] = ('NULL', type, vecSize) copy_of_params[i] = (copy_of_params[i][0], 'void', 0) if not "get" in apiutil.Properties(func_name): print('\tcrError( "%s needs to be special cased!" );' % func_name) else: print("\t%s %s = %s;" % (copy_of_params[i][1], name, ReadData(counter, copy_of_params[i][1]))) counter += apiutil.sizeof(copy_of_params[i][1]) if ("get" in apiutil.Properties(func_name)): FindReturnPointer(return_type, params) FindWritebackPointer(return_type, params) if return_type != "void": print("\t(void)", end=" ") else: print("\t", end="") print("pState->pDispatchTbl->%s(%s);" % (func_name, apiutil.MakeCallStringForDispatcher(params)))
def PrintBodies(func_name,f,no_special, gentables): #print "func_name = %s no_special = %d" % (func_name, no_special) if no_special == 1: if apiutil.FindSpecial( "packertest", func_name ): return if not allfuncs: if not apiutil.HasPackOpcode(func_name): return pointers_ok = 0 return_type = apiutil.ReturnType(func_name) params = apiutil.Parameters(func_name) if "get" in apiutil.Properties(func_name): pointers_ok = 1 if func_name == 'Writeback': pointers_ok = 1 #print "func_name = %s pointers_ok = %d no_special = %d" % (func_name, pointers_ok,no_special) #print params if gentables == 1: PrintTableFunc( func_name, params, pointers_ok ,f) else: PrintFunc( func_name, params, pointers_ok ,f)
def wrap_struct(functionName): params = apiutil.Parameters(functionName) argstring = apiutil.MakeDeclarationString(params) extendedArgstring = argstring props = apiutil.Properties(functionName) if "useclient" in props or "pixelstore" in props: extendedArgstring += ", CRClientState *c" # We'll keep track of all the parameters that require pointers. # They'll require special handling later. (pointers, pointername, pointerarg, pointertype, pointersize, pointercomment) = GetPointerInfo(functionName) # Start writing the header print 'struct instance%s {' % (functionName) print ' DLMInstanceList *next;' print ' DLMInstanceList *stateNext;' print ' int cbInstance;' print ' VBoxDLOpCode iVBoxOpCode;' print ' void (DLM_APIENTRY *execute)(DLMInstanceList *instance, SPUDispatchTable *dispatchTable);' for (name, type, vecSize) in params: # Watch out for the word "const" (which should be ignored) # and for types that end in "*" (which are pointers and need # special treatment) words = type.split() if words[0] == 'const': words = words[1:] if words[0] != "void": print ' %s %s;' % (' '.join(words), name) # If any argument was a pointer, we need a special pointer data # array. The pointer data will be stored into this array, and # references to the array will be generated as parameters. if len(pointers) == 1: if pointersize == None: print " /* Oh no - pointer parameter %s found, but no pointer class specified and can't guess */" % pointername else: if pointersize == 'special': print ' %s %s[1];%s' % (pointertype, pointerarg, pointercomment) else: print ' %s %s[%s];%s' % (pointertype, pointerarg, pointersize, pointercomment) elif len(pointers) > 1: print ' %s %s[1];%s' % (pointertype, pointerarg, pointercomment) print '};' # Pointers only happen with instances if len(pointers) > 1 or (len(pointers) == 1 and pointersize == 'special'): print 'int crdlm_pointers_%s(struct instance%s *instance, %s);' % ( functionName, functionName, extendedArgstring) # See if the GL function must sometimes allow passthrough even # if the display list is open if "checklist" in apiutil.ChromiumProps(functionName): print 'int crdlm_checklist_%s(%s);' % (functionName, argstring) return
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 '}'
print(""" /* DO NOT EDIT - THIS FILE AUTOMATICALLY GENERATED BY server_dispatch.py SCRIPT */ #include "cr_spu.h" #include "chromium.h" #include "cr_error.h" #include "server_dispatch.h" #include "server.h" #include "cr_unpack.h" CRCurrentStatePointers crServerCurrent; """) for func_name in apiutil.AllSpecials(sys.argv[1] + "/../state_tracker/state"): params = apiutil.Parameters(func_name) if (apiutil.FindSpecial("server", func_name) or "get" in apiutil.Properties(func_name)): continue wrap = apiutil.GetCategoryWrapper(func_name) if wrap: print('#if defined(CR_%s)' % wrap) print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % (func_name, apiutil.MakeDeclarationString(params))) print('{') print('\tcrState%s(%s);' % (func_name, apiutil.MakeCallString(params))) print('\tcr_server.head_spu->dispatch_table.%s(%s);' % (func_name, apiutil.MakeCallString(params))) print('}') if wrap: print('#endif')
# Generate the list of functions, starting with those coded into # the module for (returnValue, name, parameters) in additionalFunctions: if mode == 'header': print "extern %s %s(%s);" % (returnValue, name, parameters) elif mode == 'defs': print "%s" % name # Continue with functions that are auto-generated. if mode == 'header': print print "/* auto-generated compilation functions begin here */" for func_name in keys: props = apiutil.Properties(func_name) # We're interested in intercepting all calls that: # - can be put into a display list (i.e. "not ("nolist" in props)") # - change client-side state that affects saving DL elements (i.e. "setclient" in props) if apiutil.CanCompile(func_name): params = apiutil.Parameters(func_name) argstring = apiutil.MakeDeclarationString(params) if "useclient" in props or "pixelstore" in props: argstring = argstring + ", CRClientState *c" if mode == 'header': print 'extern void DLM_APIENTRY crDLMCompile%s(%s);' % (func_name, argstring) elif mode == 'defs': print "crDLMCompile%s" % func_name
apiutil.CopyrightC() print """ #ifndef HIDDENLINE_SPU_PROTO_H #define HIDDENLINE_SPU_PROTO_H 1 """ keys = apiutil.GetDispatchedFunctions("../../glapi_parser/APIspec.txt") # Determine which functions to ignore ignore_functions = [] for func_name in keys: if ("get" in apiutil.Properties(func_name) or "setclient" in apiutil.Properties(func_name) or "useclient" in apiutil.Properties(func_name) or apiutil.Category(func_name) == "Chromium" or apiutil.Category(func_name) == "GL_chromium"): ignore_functions.append(func_name) specials = apiutil.AllSpecials( "hiddenline" ) + apiutil.AllSpecials( "hiddenline_pixel" ) # emit prototypes for func_name in specials: return_type = apiutil.ReturnType(func_name) params = apiutil.Parameters(func_name) print 'extern %s HIDDENLINESPU_APIENTRY hiddenlinespu_%s(%s);' % (return_type, func_name, apiutil.MakeDeclarationString(params))
'GetTexGeniv': 'SWAP32', 'GetTexLevelParameterfv': 'SWAPFLOAT', 'GetTexLevelParameteriv': 'SWAP32', 'GetTexParameterfv': 'SWAPFLOAT', 'GetTexParameteriv': 'SWAP32' } keys = apiutil.GetDispatchedFunctions("../../glapi_parser/APIspec.txt") for func_name in keys: params = apiutil.Parameters(func_name) return_type = apiutil.ReturnType(func_name) if apiutil.FindSpecial("packspu", func_name): continue if "get" in apiutil.Properties(func_name): print '%s PACKSPU_APIENTRY packspu_%s( %s )' % ( return_type, func_name, apiutil.MakeDeclarationString(params)) print '{' print '\tGET_THREAD(thread);' print '\tint writeback = 1;' if return_type != 'void': print '\t%s return_val = (%s) 0;' % (return_type, return_type) params.append(("&return_val", "foo", 0)) if (func_name in easy_swaps.keys() and easy_swaps[func_name] != '0' ) or func_name in simple_funcs or func_name in hard_funcs.keys(): print '\tunsigned int i;' print '\tif (!(pack_spu.thread[0].netServer.conn->actual_network))' print '\t{' print '\t\tcrError( "packspu_%s doesn\'t work when there\'s no actual network involved!\\nTry using the simplequery SPU in your chain!" );' % func_name print '\t}'
for func_name in keys: if ("pack" in apiutil.ChromiumProps(func_name) or "extpack" in apiutil.ChromiumProps(func_name) or apiutil.NonVectorFunction(func_name) != '' or apiutil.FindSpecial('packer', func_name)): # OK, generate a crPackFooBar() prototype for this function return_type = apiutil.ReturnType(func_name) args = apiutil.Parameters(func_name) if return_type != 'void': if apiutil.IsPointer(return_type): args.append(("return_value", return_type, 0)) else: args.append(("return_value", return_type + "*", 0)) elif "pixelstore" in apiutil.Properties(func_name): args.append(("packstate", "const CRPixelPackState *", 0)) if "get" in apiutil.Properties(func_name): args.append(("writeback", "int *", 0)) print 'void PACK_APIENTRY crPack%s( %s );' % ( func_name, apiutil.MakeDeclarationString(args)) print 'void PACK_APIENTRY crPack%sSWAP( %s );' % ( func_name, apiutil.MakeDeclarationString(args)) # Now generate special BBOX, COUNT, SWAP variations on the glVertex and # glVertexAttrib functions. for func_name in keys: if (func_name[0:6] == "Vertex" and "pervertex" in apiutil.Properties(func_name)
def PrintFunc(func_name, params, is_swapped, can_have_pointers): """Emit a packer function.""" if is_swapped: print('void PACK_APIENTRY crPack%sSWAP(%s)' % (func_name, apiutil.MakeDeclarationStringWithContext( 'CR_PACKER_CONTEXT', params))) else: print('void PACK_APIENTRY crPack%s(%s)' % (func_name, apiutil.MakeDeclarationStringWithContext( 'CR_PACKER_CONTEXT', params))) print('{') print('\tCR_GET_PACKER_CONTEXT(pc);') # Save original function name orig_func_name = func_name # Convert to a non-vector version of the function if possible func_name = apiutil.NonVectorFunction(func_name) if not func_name: func_name = orig_func_name # Check if there are any pointer parameters. # That's usually a problem so we'll emit an error function. nonVecParams = apiutil.Parameters(func_name) bail_out = 0 for (name, type, vecSize) in nonVecParams: if apiutil.IsPointer(type) and vecSize == 0 and not can_have_pointers: bail_out = 1 if bail_out: for (name, type, vecSize) in nonVecParams: print('\t(void)%s;' % (name)) print('\tcrError ( "%s needs to be special cased %d %d!");' % (func_name, vecSize, can_have_pointers)) print('\t(void) pc;') print('}') # XXX we should really abort here return if "extpack" in apiutil.ChromiumProps(func_name): is_extended = 1 else: is_extended = 0 print("\tunsigned char *data_ptr;") print('\t(void) pc;') #if func_name == "Enable" or func_name == "Disable": # print "\tCRASSERT(!pc->buffer.geometry_only); /* sanity check */" for index in range(0, len(params)): (name, type, vecSize) = params[index] if vecSize > 0 and func_name != orig_func_name: print(" if (!%s) {" % name) # Know the reason for this one, so avoid the spam. if orig_func_name != "SecondaryColor3fvEXT": print(" crDebug(\"App passed NULL as %s for %s\");" % (name, orig_func_name)) print(" return;") print(" }") packet_length = apiutil.PacketLength(nonVecParams) if packet_length == 0 and not is_extended: print("\tCR_GET_BUFFERED_POINTER_NO_ARGS(pc);") elif func_name[:9] == "Translate" or func_name[:5] == "Color": # XXX WTF is the purpose of this? if is_extended: packet_length += 8 print("\tCR_GET_BUFFERED_POINTER_NO_BEGINEND_FLUSH(pc, %d, GL_TRUE);" % packet_length) else: if is_extended: packet_length += 8 print("\tCR_GET_BUFFERED_POINTER(pc, %d);" % packet_length) UpdateCurrentPointer(func_name) if is_extended: counter = 8 print(WriteData(0, 'GLint', packet_length, is_swapped)) print( WriteData(4, 'GLenum', apiutil.ExtendedOpcodeName(func_name), is_swapped)) else: counter = 0 # Now emit the WRITE_() macros for all parameters for index in range(0, len(params)): (name, type, vecSize) = params[index] # if we're converting a vector-valued function to a non-vector func: if vecSize > 0 and func_name != orig_func_name: ptrType = apiutil.PointerType(type) for i in range(0, vecSize): print( WriteData(counter + i * apiutil.sizeof(ptrType), ptrType, "%s[%d]" % (name, i), is_swapped)) # XXX increment counter here? else: print(WriteData(counter, type, name, is_swapped)) if apiutil.IsPointer(type): counter += apiutil.PointerSize() else: counter += apiutil.sizeof(type) # finish up if is_extended: print("\tWRITE_OPCODE(pc, CR_EXTEND_OPCODE);") else: print("\tWRITE_OPCODE(pc, %s);" % apiutil.OpcodeName(func_name)) if "get" in apiutil.Properties(func_name): print('\tCR_CMDBLOCK_CHECK_FLUSH(pc);') print('\tCR_UNLOCK_PACKER_CONTEXT(pc);') print('}\n')
# # See the file LICENSE.txt for information on redistributing this software. import sys sys.path.append("../../glapi_parser") import apiutil apiutil.CopyrightC() print """#include <stdio.h> #include "cr_spu.h" #include "cr_glstate.h" #include "state/cr_stateerror.h" #include "simplequeryspu.h" """ specials = ["WindowCreate", "CreateContext"] apiutil.GetAllFunctions("../../glapi_parser/APIspec.txt") keys = apiutil.GetDispatchedFunctions() print 'SPUNamedFunctionTable _cr_simplequery_table[] = {' for func_name in keys: if not func_name in specials and "get" in apiutil.Properties(func_name): print '\t{ "%s", (SPUGenericFunction) crState%s },' % (func_name, func_name) print "\t{ NULL, NULL }" print "};"