3 # (C) Copyright IBM Corporation 2005
6 # Permission is hereby granted, free of charge, to any person obtaining a
7 # copy of this software and associated documentation files (the "Software"),
8 # to deal in the Software without restriction, including without limitation
9 # on the rights to use, copy, modify, merge, publish, distribute, sub
10 # license, and/or sell copies of the Software, and to permit persons to whom
11 # the Software is furnished to do so, subject to the following conditions:
13 # The above copyright notice and this permission notice (including the next
14 # paragraph) shall be included in all copies or substantial portions of the
17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
20 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
26 # Ian Romanick <idr@us.ibm.com>
28 import gl_XML, glX_XML, glX_proto_common, license
29 import sys, getopt, string
32 class PrintGlxDispatch_h(gl_XML.gl_print_base):
34 gl_XML.gl_print_base.__init__(self)
36 self.name = "glX_proto_recv.py (from Mesa)"
37 self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2005", "IBM")
39 self.header_tag = "_INDIRECT_DISPATCH_H_"
43 def printRealHeader(self):
44 self.printVisibility( "HIDDEN", "hidden" )
45 print 'struct __GLXclientStateRec;'
50 def printBody(self, api):
51 for func in api.functionIterateAll():
52 if not func.ignore and not func.vectorequiv:
54 print 'extern HIDDEN void __glXDisp_%s(GLbyte * pc);' % (func.name)
55 print 'extern HIDDEN void __glXDispSwap_%s(GLbyte * pc);' % (func.name)
56 elif func.glx_sop or func.glx_vendorpriv:
57 print 'extern HIDDEN int __glXDisp_%s(struct __GLXclientStateRec *, GLbyte *);' % (func.name)
58 print 'extern HIDDEN int __glXDispSwap_%s(struct __GLXclientStateRec *, GLbyte *);' % (func.name)
60 if func.glx_sop and func.glx_vendorpriv:
61 n = func.glx_vendorpriv_names[0]
62 print 'extern HIDDEN int __glXDisp_%s(struct __GLXclientStateRec *, GLbyte *);' % (n)
63 print 'extern HIDDEN int __glXDispSwap_%s(struct __GLXclientStateRec *, GLbyte *);' % (n)
68 class PrintGlxDispatchFunctions(glX_proto_common.glx_print_proto):
69 def __init__(self, do_swap):
70 gl_XML.gl_print_base.__init__(self)
71 self.name = "glX_proto_recv.py (from Mesa)"
72 self.license = license.bsd_license_template % ( "(C) Copyright IBM Corporation 2005", "IBM")
74 self.real_types = [ '', '', 'uint16_t', '', 'uint32_t', '', '', '', 'uint64_t' ]
75 self.do_swap = do_swap
79 def printRealHeader(self):
80 print '#include <X11/Xmd.h>'
81 print '#include <GL/gl.h>'
82 print '#include <GL/glxproto.h>'
84 print '#include <inttypes.h>'
85 print '#include "indirect_size.h"'
86 print '#include "indirect_size_get.h"'
87 print '#include "indirect_dispatch.h"'
88 print '#include "glxserver.h"'
89 print '#include "glxbyteorder.h"'
90 print '#include "indirect_util.h"'
91 print '#include "singlesize.h"'
92 print '#include "glapi.h"'
93 print '#include "glapitable.h"'
94 print '#include "glthread.h"'
95 print '#include "glapidispatch.h"'
97 print '#define __GLX_PAD(x) (((x) + 3) & ~3)'
99 print 'typedef struct {'
100 print ' __GLX_PIXEL_3D_HDR;'
101 print '} __GLXpixel3DHeader;'
103 print 'extern GLboolean __glXErrorOccured( void );'
104 print 'extern void __glXClearErrorOccured( void );'
106 print 'static const unsigned dummy_answer[2] = {0, 0};'
111 def printBody(self, api):
113 self.emit_swap_wrappers(api)
116 for func in api.functionIterateByOffset():
117 if not func.ignore and not func.server_handcode and not func.vectorequiv and (func.glx_rop or func.glx_sop or func.glx_vendorpriv):
118 self.printFunction(func, func.name)
119 if func.glx_sop and func.glx_vendorpriv:
120 self.printFunction(func, func.glx_vendorpriv_names[0])
126 def printFunction(self, f, name):
127 if (f.glx_sop or f.glx_vendorpriv) and (len(f.get_images()) != 0):
133 base = '__glXDispSwap'
136 print 'void %s_%s(GLbyte * pc)' % (base, name)
138 print 'int %s_%s(__GLXclientState *cl, GLbyte *pc)' % (base, name)
142 if f.glx_rop or f.vectorequiv:
143 self.printRenderFunction(f)
144 elif f.glx_sop or f.glx_vendorpriv:
145 if len(f.get_images()) == 0:
146 self.printSingleFunction(f, name)
148 print "/* Missing GLX protocol for %s. */" % (name)
155 def swap_name(self, bytes):
156 return 'bswap_%u_array' % (8 * bytes)
159 def emit_swap_wrappers(self, api):
163 for t in api.typeIterate():
164 te = t.get_type_expression()
165 t_size = te.get_element_size()
167 if t_size > 1 and t.glx_name:
169 t_name = "GL" + t.name
170 self.type_map[ t_name ] = t.glx_name
172 if t.glx_name not in already_done:
173 real_name = self.real_types[t_size]
175 print 'static %s' % (t_name)
176 print 'bswap_%s( const void * src )' % (t.glx_name)
178 print ' union { %s dst; %s ret; } x;' % (real_name, t_name)
179 print ' x.dst = bswap_%u( *(%s *) src );' % (t_size * 8, real_name)
180 print ' return x.ret;'
183 already_done.append( t.glx_name )
185 for bits in [16, 32, 64]:
186 print 'static void *'
187 print 'bswap_%u_array( uint%u_t * src, unsigned count )' % (bits, bits)
191 print ' for ( i = 0 ; i < count ; i++ ) {'
192 print ' uint%u_t temp = bswap_%u( src[i] );' % (bits, bits)
193 print ' src[i] = temp;'
201 def fetch_param(self, param):
202 t = param.type_string()
204 element_size = param.size() / param.get_element_count()
206 if self.do_swap and (element_size != 1):
208 real_name = self.real_types[ element_size ]
210 swap_func = self.swap_name( element_size )
211 return ' (%-8s)%s( (%s *) (pc + %2s), %s )' % (t, swap_func, real_name, o, param.count)
213 t_name = param.get_base_type_string()
214 return ' (%-8s)bswap_%-7s( pc + %2s )' % (t, self.type_map[ t_name ], o)
217 return ' (%-8s)(pc + %2u)' % (t, o)
219 return '*(%-8s *)(pc + %2u)' % (t, o)
224 def emit_function_call(self, f, retval_assign, indent):
227 for param in f.parameterIterator():
231 if param.is_counter or param.is_image() or param.is_output or param.name in f.count_parameter_list or len(param.count_parameter_list):
232 location = param.name
234 location = self.fetch_param(param)
236 list.append( '%s %s' % (indent, location) )
240 print '%s %sCALL_%s( GET_DISPATCH(), (' % (indent, retval_assign, f.name)
241 print string.join( list, ",\n" )
242 print '%s ) );' % (indent)
244 print '%s %sCALL_%s( GET_DISPATCH(), () );' % (indent, retval_assign, f.name)
248 def common_func_print_just_start(self, f, indent):
253 f.calculate_offsets()
254 for param in f.parameterIterateGlxSend():
255 # If any parameter has a 64-bit base type, then we
256 # have to do alignment magic for the while thing.
258 if param.is_64_bit():
262 # FIXME img_null_flag is over-loaded. In addition to
263 # FIXME being used for images, it is used to signify
264 # FIXME NULL data pointers for vertex buffer object
265 # FIXME related functions. Re-name it to null_data
266 # FIXME or something similar.
268 if param.img_null_flag:
269 print '%s const CARD32 ptr_is_null = *(CARD32 *)(pc + %s);' % (indent, param.offset - 4)
270 cond = '(ptr_is_null != 0) ? NULL : '
275 type_string = param.type_string()
278 offset = f.offset_of( param.name )
280 print '%s %s const %s = (%s) (%s(pc + %s));' % (indent, type_string, param.name, type_string, cond, offset)
283 print '%s __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);' % (indent)
285 print '%s __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);' % (indent)
288 elif param.is_counter or param.name in f.count_parameter_list:
289 location = self.fetch_param(param)
290 print '%s const %s %s = %s;' % (indent, type_string, param.name, location)
292 elif len(param.count_parameter_list):
293 if param.size() == 1 and not self.do_swap:
294 location = self.fetch_param(param)
295 print '%s %s %s = %s%s;' % (indent, type_string, param.name, cond, location)
297 print '%s %s %s;' % (indent, type_string, param.name)
306 print '#ifdef __GLX_ALIGN64'
308 if f.has_variable_size_request():
309 self.emit_packet_size_calculation(f, 4)
312 s = str((f.command_fixed_length() + 3) & ~3)
314 print ' if ((unsigned long)(pc) & 7) {'
315 print ' (void) memmove(pc-4, pc, %s);' % (s)
324 for param in f.parameterIterateGlxSend():
325 if param.count_parameter_list:
327 count = param.get_element_count()
328 type_size = param.size() / count
331 count_name = param.counter
333 count_name = str(count)
335 # This is basically an ugly special-
336 # case for glCallLists.
340 x.append( [1, ['BYTE', 'UNSIGNED_BYTE', '2_BYTES', '3_BYTES', '4_BYTES']] )
341 x.append( [2, ['SHORT', 'UNSIGNED_SHORT']] )
342 x.append( [4, ['INT', 'UNSIGNED_INT', 'FLOAT']] )
344 print ' switch(%s) {' % (param.count_parameter_list[0])
346 for t_name in sub[1]:
347 print ' case GL_%s:' % (t_name)
350 print ' %s = (%s) (pc + %s); break;' % (param.name, param.type_string(), o)
352 swap_func = self.swap_name(sub[0])
353 print ' %s = (%s) %s( (%s *) (pc + %s), %s ); break;' % (param.name, param.type_string(), swap_func, self.real_types[sub[0]], o, count_name)
358 swap_func = self.swap_name(type_size)
359 compsize = self.size_call(f, 1)
360 print ' %s = (%s) %s( (%s *) (pc + %s), %s );' % (param.name, param.type_string(), swap_func, self.real_types[type_size], o, compsize)
365 for param in f.parameterIterateGlxSend():
366 if param.count_parameter_list:
367 print '%s %s = (%s) (pc + %s);' % (indent, param.name, param.type_string(), param.offset)
378 def printSingleFunction(self, f, name):
379 if name not in f.glx_vendorpriv_names:
380 print ' xGLXSingleReq * const req = (xGLXSingleReq *) pc;'
382 print ' xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;'
387 print ' __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);'
389 print ' __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);'
392 if name not in f.glx_vendorpriv_names:
393 print ' pc += __GLX_SINGLE_HDR_SIZE;'
395 print ' pc += __GLX_VENDPRIV_HDR_SIZE;'
397 print ' if ( cx != NULL ) {'
398 self.common_func_print_just_start(f, " ")
401 if f.return_type != 'void':
402 print ' %s retval;' % (f.return_type)
403 retval_string = "retval"
404 retval_assign = "retval = "
411 answer_string = "dummy_answer"
413 is_array_string = "GL_FALSE"
415 for param in f.parameterIterateOutputs():
416 answer_type = param.get_base_type_string()
417 if answer_type == "GLvoid":
418 answer_type = "GLubyte"
421 c = param.get_element_count()
422 type_size = (param.size() / c)
426 size_scale = " * %u" % (type_size)
429 if param.count_parameter_list:
430 print ' const GLuint compsize = %s;' % (self.size_call(f, 1))
431 print ' %s answerBuffer[200];' % (answer_type)
432 print ' %s %s = __glXGetAnswerBuffer(cl, compsize%s, answerBuffer, sizeof(answerBuffer), %u);' % (param.type_string(), param.name, size_scale, type_size )
433 answer_string = param.name
434 answer_count = "compsize"
437 print ' if (%s == NULL) return BadAlloc;' % (param.name)
438 print ' __glXClearErrorOccured();'
441 print ' %s answerBuffer[200];' % (answer_type)
442 print ' %s %s = __glXGetAnswerBuffer(cl, %s%s, answerBuffer, sizeof(answerBuffer), %u);' % (param.type_string(), param.name, param.counter, size_scale, type_size)
443 answer_string = param.name
444 answer_count = param.counter
446 print ' %s %s[%u];' % (answer_type, param.name, c)
447 answer_string = param.name
448 answer_count = "%u" % (c)
450 if f.reply_always_array:
451 is_array_string = "GL_TRUE"
454 self.emit_function_call(f, retval_assign, " ")
459 for param in f.parameterIterateOutputs():
460 c = param.get_element_count()
461 type_size = (param.size() / c)
464 swap_name = self.swap_name( type_size )
465 print ' (void) %s( (uint%u_t *) %s, %s );' % (swap_name, 8 * type_size, param.name, answer_count)
468 reply_func = '__glXSendReplySwap'
470 reply_func = '__glXSendReply'
472 print ' %s(cl->client, %s, %s, %u, %s, %s);' % (reply_func, answer_string, answer_count, type_size, is_array_string, retval_string)
473 #elif f.note_unflushed:
474 # print ' cx->hasUnflushedCommands = GL_TRUE;'
476 print ' error = Success;'
479 print ' return error;'
483 def printRenderFunction(self, f):
484 # There are 4 distinct phases in a rendering dispatch function.
485 # In the first phase we compute the sizes and offsets of each
486 # element in the command. In the second phase we (optionally)
487 # re-align 64-bit data elements. In the third phase we
488 # (optionally) byte-swap array data. Finally, in the fourth
489 # phase we actually dispatch the function.
491 self.common_func_print_just_start(f, "")
493 images = f.get_images()
496 pre = "bswap_CARD32( & "
504 # swapBytes and lsbFirst are single byte fields, so
505 # the must NEVER be byte-swapped.
507 if not (img.img_type == "GL_BITMAP" and img.img_format == "GL_COLOR_INDEX"):
508 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) );'
510 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );'
512 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) %shdr->rowLength%s) );' % (pre, post)
514 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) %shdr->imageHeight%s) );' % (pre, post)
515 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) %shdr->skipRows%s) );' % (pre, post)
517 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES, (GLint) %shdr->skipImages%s) );' % (pre, post)
518 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) %shdr->skipPixels%s) );' % (pre, post)
519 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) %shdr->alignment%s) );' % (pre, post)
523 self.emit_function_call(f, "", "")
527 if __name__ == '__main__':
528 file_name = "gl_API.xml"
531 (args, trail) = getopt.getopt(sys.argv[1:], "f:m:s")
537 for (arg,val) in args:
545 if mode == "dispatch_c":
546 printer = PrintGlxDispatchFunctions(do_swap)
547 elif mode == "dispatch_h":
548 printer = PrintGlxDispatch_h()
552 api = gl_XML.parse_GL_API( file_name, glX_proto_common.glx_proto_item_factory() )