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>
31 import gl_XML
, glX_XML
, glX_proto_common
, license
34 class PrintGlxDispatch_h(gl_XML
.gl_print_base
):
36 gl_XML
.gl_print_base
.__init
__(self
)
38 self
.name
= "glX_proto_recv.py (from Mesa)"
39 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2005", "IBM")
41 self
.header_tag
= "_INDIRECT_DISPATCH_H_"
45 def printRealHeader(self
):
46 print '# include <X11/Xfuncproto.h>'
48 print 'struct __GLXclientStateRec;'
53 def printBody(self
, api
):
54 for func
in api
.functionIterateAll():
55 if not func
.ignore
and not func
.vectorequiv
:
57 print 'extern _X_HIDDEN void __glXDisp_%s(GLbyte * pc);' % (func
.name
)
58 print 'extern _X_HIDDEN void __glXDispSwap_%s(GLbyte * pc);' % (func
.name
)
59 elif func
.glx_sop
or func
.glx_vendorpriv
:
60 print 'extern _X_HIDDEN int __glXDisp_%s(struct __GLXclientStateRec *, GLbyte *);' % (func
.name
)
61 print 'extern _X_HIDDEN int __glXDispSwap_%s(struct __GLXclientStateRec *, GLbyte *);' % (func
.name
)
63 if func
.glx_sop
and func
.glx_vendorpriv
:
64 n
= func
.glx_vendorpriv_names
[0]
65 print 'extern _X_HIDDEN int __glXDisp_%s(struct __GLXclientStateRec *, GLbyte *);' % (n
)
66 print 'extern _X_HIDDEN int __glXDispSwap_%s(struct __GLXclientStateRec *, GLbyte *);' % (n
)
71 class PrintGlxDispatchFunctions(glX_proto_common
.glx_print_proto
):
72 def __init__(self
, do_swap
):
73 gl_XML
.gl_print_base
.__init
__(self
)
74 self
.name
= "glX_proto_recv.py (from Mesa)"
75 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2005", "IBM")
77 self
.real_types
= [ '', '', 'uint16_t', '', 'uint32_t', '', '', '', 'uint64_t' ]
78 self
.do_swap
= do_swap
82 def printRealHeader(self
):
83 print '#include <X11/Xmd.h>'
84 print '#include <GL/gl.h>'
85 print '#include <GL/glxproto.h>'
87 print '#include <inttypes.h>'
88 print '#include "indirect_size.h"'
89 print '#include "indirect_size_get.h"'
90 print '#include "indirect_dispatch.h"'
91 print '#include "glxserver.h"'
92 print '#include "glxbyteorder.h"'
93 print '#include "indirect_util.h"'
94 print '#include "singlesize.h"'
95 print '#include "glapi.h"'
96 print '#include "glapitable.h"'
97 print '#include "dispatch.h"'
99 print '#define __GLX_PAD(x) (((x) + 3) & ~3)'
101 print 'typedef struct {'
102 print ' __GLX_PIXEL_3D_HDR;'
103 print '} __GLXpixel3DHeader;'
105 print 'extern GLboolean __glXErrorOccured( void );'
106 print 'extern void __glXClearErrorOccured( void );'
108 print 'static const unsigned dummy_answer[2] = {0, 0};'
113 def printBody(self
, api
):
115 self
.emit_swap_wrappers(api
)
118 for func
in api
.functionIterateByOffset():
119 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
):
120 self
.printFunction(func
, func
.name
)
121 if func
.glx_sop
and func
.glx_vendorpriv
:
122 self
.printFunction(func
, func
.glx_vendorpriv_names
[0])
128 def printFunction(self
, f
, name
):
129 if (f
.glx_sop
or f
.glx_vendorpriv
) and (len(f
.get_images()) != 0):
135 base
= '__glXDispSwap'
138 print 'void %s_%s(GLbyte * pc)' % (base
, name
)
140 print 'int %s_%s(__GLXclientState *cl, GLbyte *pc)' % (base
, name
)
144 if f
.glx_rop
or f
.vectorequiv
:
145 self
.printRenderFunction(f
)
146 elif f
.glx_sop
or f
.glx_vendorpriv
:
147 if len(f
.get_images()) == 0:
148 self
.printSingleFunction(f
, name
)
150 print "/* Missing GLX protocol for %s. */" % (name
)
157 def swap_name(self
, bytes
):
158 return 'bswap_%u_array' % (8 * bytes
)
161 def emit_swap_wrappers(self
, api
):
165 for t
in api
.typeIterate():
166 te
= t
.get_type_expression()
167 t_size
= te
.get_element_size()
169 if t_size
> 1 and t
.glx_name
:
171 t_name
= "GL" + t
.name
172 self
.type_map
[ t_name
] = t
.glx_name
174 if t
.glx_name
not in already_done
:
175 real_name
= self
.real_types
[t_size
]
177 print 'static %s' % (t_name
)
178 print 'bswap_%s( const void * src )' % (t
.glx_name
)
180 print ' union { %s dst; %s ret; } x;' % (real_name
, t_name
)
181 print ' x.dst = bswap_%u( *(%s *) src );' % (t_size
* 8, real_name
)
182 print ' return x.ret;'
185 already_done
.append( t
.glx_name
)
187 for bits
in [16, 32, 64]:
188 print 'static void *'
189 print 'bswap_%u_array( uint%u_t * src, unsigned count )' % (bits
, bits
)
193 print ' for ( i = 0 ; i < count ; i++ ) {'
194 print ' uint%u_t temp = bswap_%u( src[i] );' % (bits
, bits
)
195 print ' src[i] = temp;'
203 def fetch_param(self
, param
):
204 t
= param
.type_string()
206 element_size
= param
.size() / param
.get_element_count()
208 if self
.do_swap
and (element_size
!= 1):
210 real_name
= self
.real_types
[ element_size
]
212 swap_func
= self
.swap_name( element_size
)
213 return ' (%-8s)%s( (%s *) (pc + %2s), %s )' % (t
, swap_func
, real_name
, o
, param
.count
)
215 t_name
= param
.get_base_type_string()
216 return ' (%-8s)bswap_%-7s( pc + %2s )' % (t
, self
.type_map
[ t_name
], o
)
219 return ' (%-8s)(pc + %2u)' % (t
, o
)
221 return '*(%-8s *)(pc + %2u)' % (t
, o
)
226 def emit_function_call(self
, f
, retval_assign
, indent
):
229 for param
in f
.parameterIterator():
233 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
):
234 location
= param
.name
236 location
= self
.fetch_param(param
)
238 list.append( '%s %s' % (indent
, location
) )
242 print '%s %sCALL_%s( GET_DISPATCH(), (' % (indent
, retval_assign
, f
.name
)
243 print string
.join( list, ",\n" )
244 print '%s ) );' % (indent
)
246 print '%s %sCALL_%s( GET_DISPATCH(), () );' % (indent
, retval_assign
, f
.name
)
250 def common_func_print_just_start(self
, f
, indent
):
255 f
.calculate_offsets()
256 for param
in f
.parameterIterateGlxSend():
257 # If any parameter has a 64-bit base type, then we
258 # have to do alignment magic for the while thing.
260 if param
.is_64_bit():
264 # FIXME img_null_flag is over-loaded. In addition to
265 # FIXME being used for images, it is used to signify
266 # FIXME NULL data pointers for vertex buffer object
267 # FIXME related functions. Re-name it to null_data
268 # FIXME or something similar.
270 if param
.img_null_flag
:
271 print '%s const CARD32 ptr_is_null = *(CARD32 *)(pc + %s);' % (indent
, param
.offset
- 4)
272 cond
= '(ptr_is_null != 0) ? NULL : '
277 type_string
= param
.type_string()
280 offset
= f
.offset_of( param
.name
)
282 print '%s %s const %s = (%s) (%s(pc + %s));' % (indent
, type_string
, param
.name
, type_string
, cond
, offset
)
285 print '%s __GLXpixel3DHeader * const hdr = (__GLXpixel3DHeader *)(pc);' % (indent
)
287 print '%s __GLXpixelHeader * const hdr = (__GLXpixelHeader *)(pc);' % (indent
)
290 elif param
.is_counter
or param
.name
in f
.count_parameter_list
:
291 location
= self
.fetch_param(param
)
292 print '%s const %s %s = %s;' % (indent
, type_string
, param
.name
, location
)
294 elif len(param
.count_parameter_list
):
295 if param
.size() == 1 and not self
.do_swap
:
296 location
= self
.fetch_param(param
)
297 print '%s %s %s = %s%s;' % (indent
, type_string
, param
.name
, cond
, location
)
299 print '%s %s %s;' % (indent
, type_string
, param
.name
)
308 print '#ifdef __GLX_ALIGN64'
310 if f
.has_variable_size_request():
311 self
.emit_packet_size_calculation(f
, 4)
314 s
= str((f
.command_fixed_length() + 3) & ~
3)
316 print ' if ((unsigned long)(pc) & 7) {'
317 print ' (void) memmove(pc-4, pc, %s);' % (s
)
326 for param
in f
.parameterIterateGlxSend():
327 if param
.count_parameter_list
:
329 count
= param
.get_element_count()
330 type_size
= param
.size() / count
333 count_name
= param
.counter
335 count_name
= str(count
)
337 # This is basically an ugly special-
338 # case for glCallLists.
342 x
.append( [1, ['BYTE', 'UNSIGNED_BYTE', '2_BYTES', '3_BYTES', '4_BYTES']] )
343 x
.append( [2, ['SHORT', 'UNSIGNED_SHORT']] )
344 x
.append( [4, ['INT', 'UNSIGNED_INT', 'FLOAT']] )
346 print ' switch(%s) {' % (param
.count_parameter_list
[0])
348 for t_name
in sub
[1]:
349 print ' case GL_%s:' % (t_name
)
352 print ' %s = (%s) (pc + %s); break;' % (param
.name
, param
.type_string(), o
)
354 swap_func
= self
.swap_name(sub
[0])
355 print ' %s = (%s) %s( (%s *) (pc + %s), %s ); break;' % (param
.name
, param
.type_string(), swap_func
, self
.real_types
[sub
[0]], o
, count_name
)
360 swap_func
= self
.swap_name(type_size
)
361 compsize
= self
.size_call(f
, 1)
362 print ' %s = (%s) %s( (%s *) (pc + %s), %s );' % (param
.name
, param
.type_string(), swap_func
, self
.real_types
[type_size
], o
, compsize
)
367 for param
in f
.parameterIterateGlxSend():
368 if param
.count_parameter_list
:
369 print '%s %s = (%s) (pc + %s);' % (indent
, param
.name
, param
.type_string(), param
.offset
)
380 def printSingleFunction(self
, f
, name
):
381 if name
not in f
.glx_vendorpriv_names
:
382 print ' xGLXSingleReq * const req = (xGLXSingleReq *) pc;'
384 print ' xGLXVendorPrivateReq * const req = (xGLXVendorPrivateReq *) pc;'
389 print ' __GLXcontext * const cx = __glXForceCurrent(cl, bswap_CARD32( &req->contextTag ), &error);'
391 print ' __GLXcontext * const cx = __glXForceCurrent(cl, req->contextTag, &error);'
394 if name
not in f
.glx_vendorpriv_names
:
395 print ' pc += __GLX_SINGLE_HDR_SIZE;'
397 print ' pc += __GLX_VENDPRIV_HDR_SIZE;'
399 print ' if ( cx != NULL ) {'
400 self
.common_func_print_just_start(f
, " ")
403 if f
.return_type
!= 'void':
404 print ' %s retval;' % (f
.return_type
)
405 retval_string
= "retval"
406 retval_assign
= "retval = "
413 answer_string
= "dummy_answer"
415 is_array_string
= "GL_FALSE"
417 for param
in f
.parameterIterateOutputs():
418 answer_type
= param
.get_base_type_string()
419 if answer_type
== "GLvoid":
420 answer_type
= "GLubyte"
423 c
= param
.get_element_count()
424 type_size
= (param
.size() / c
)
428 size_scale
= " * %u" % (type_size
)
431 if param
.count_parameter_list
:
432 print ' const GLuint compsize = %s;' % (self
.size_call(f
, 1))
433 print ' %s answerBuffer[200];' % (answer_type
)
434 print ' %s %s = __glXGetAnswerBuffer(cl, compsize%s, answerBuffer, sizeof(answerBuffer), %u);' % (param
.type_string(), param
.name
, size_scale
, type_size
)
435 answer_string
= param
.name
436 answer_count
= "compsize"
439 print ' if (%s == NULL) return BadAlloc;' % (param
.name
)
440 print ' __glXClearErrorOccured();'
443 print ' %s answerBuffer[200];' % (answer_type
)
444 print ' %s %s = __glXGetAnswerBuffer(cl, %s%s, answerBuffer, sizeof(answerBuffer), %u);' % (param
.type_string(), param
.name
, param
.counter
, size_scale
, type_size
)
445 answer_string
= param
.name
446 answer_count
= param
.counter
448 print ' %s %s[%u];' % (answer_type
, param
.name
, c
)
449 answer_string
= param
.name
450 answer_count
= "%u" % (c
)
452 if f
.reply_always_array
:
453 is_array_string
= "GL_TRUE"
456 self
.emit_function_call(f
, retval_assign
, " ")
461 for param
in f
.parameterIterateOutputs():
462 c
= param
.get_element_count()
463 type_size
= (param
.size() / c
)
466 swap_name
= self
.swap_name( type_size
)
467 print ' (void) %s( (uint%u_t *) %s, %s );' % (swap_name
, 8 * type_size
, param
.name
, answer_count
)
470 reply_func
= '__glXSendReplySwap'
472 reply_func
= '__glXSendReply'
474 print ' %s(cl->client, %s, %s, %u, %s, %s);' % (reply_func
, answer_string
, answer_count
, type_size
, is_array_string
, retval_string
)
475 #elif f.note_unflushed:
476 # print ' cx->hasUnflushedCommands = GL_TRUE;'
478 print ' error = Success;'
481 print ' return error;'
485 def printRenderFunction(self
, f
):
486 # There are 4 distinct phases in a rendering dispatch function.
487 # In the first phase we compute the sizes and offsets of each
488 # element in the command. In the second phase we (optionally)
489 # re-align 64-bit data elements. In the third phase we
490 # (optionally) byte-swap array data. Finally, in the fourth
491 # phase we actually dispatch the function.
493 self
.common_func_print_just_start(f
, "")
495 images
= f
.get_images()
498 pre
= "bswap_CARD32( & "
506 # swapBytes and lsbFirst are single byte fields, so
507 # the must NEVER be byte-swapped.
509 if not (img
.img_type
== "GL_BITMAP" and img
.img_format
== "GL_COLOR_INDEX"):
510 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SWAP_BYTES, hdr->swapBytes) );'
512 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_LSB_FIRST, hdr->lsbFirst) );'
514 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ROW_LENGTH, (GLint) %shdr->rowLength%s) );' % (pre
, post
)
516 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_IMAGE_HEIGHT, (GLint) %shdr->imageHeight%s) );' % (pre
, post
)
517 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_ROWS, (GLint) %shdr->skipRows%s) );' % (pre
, post
)
519 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_IMAGES, (GLint) %shdr->skipImages%s) );' % (pre
, post
)
520 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_SKIP_PIXELS, (GLint) %shdr->skipPixels%s) );' % (pre
, post
)
521 print ' CALL_PixelStorei( GET_DISPATCH(), (GL_UNPACK_ALIGNMENT, (GLint) %shdr->alignment%s) );' % (pre
, post
)
525 self
.emit_function_call(f
, "", "")
530 """Parse any arguments passed and return a namespace."""
531 parser
= argparse
.ArgumentParser()
532 parser
.add_argument('-f',
534 default
='gl_API.xml',
535 help='an xml file describing an OpenGL API')
536 parser
.add_argument('-m',
538 default
='dispatch_c',
539 choices
=['dispatch_c', 'dispatch_h'],
540 help='what file to generate')
541 parser
.add_argument('-s',
544 help='emit swap in GlXDispatchFunctions')
545 return parser
.parse_args()
552 if args
.mode
== "dispatch_c":
553 printer
= PrintGlxDispatchFunctions(args
.swap
)
554 elif args
.mode
== "dispatch_h":
555 printer
= PrintGlxDispatch_h()
557 api
= gl_XML
.parse_GL_API(
558 args
.filename
, glX_proto_common
.glx_proto_item_factory())
563 if __name__
== '__main__':