3 # (C) Copyright IBM Corporation 2004, 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>
27 # Jeremy Kolb <jkolb@brandeis.edu>
29 import gl_XML
, glX_XML
, glX_proto_common
, license
30 import sys
, getopt
, copy
, string
32 def convertStringForXCB(str):
37 if str[i
:i
+3] in special
:
38 tmp
= '%s_%s' % (tmp
, string
.lower(str[i
:i
+3]))
40 elif str[i
].isupper():
41 tmp
= '%s_%s' % (tmp
, string
.lower(str[i
]))
43 tmp
= '%s%s' % (tmp
, str[i
])
47 def hash_pixel_function(func
):
48 """Generate a 'unique' key for a pixel function. The key is based on
49 the parameters written in the command packet. This includes any
50 padding that might be added for the original function and the 'NULL
57 for param
in func
.parameterIterateGlxSend():
59 [dim
, junk
, junk
, junk
, junk
] = param
.get_dimensions()
62 hash_pre
= "%uD%uD_" % (d
- 1, d
)
64 if param
.img_null_flag
:
67 h
+= "%u" % (param
.size())
69 if func
.pad_after(param
):
73 n
= func
.name
.replace("%uD" % (dim
), "")
74 n
= "__glx_%s_%uD%uD" % (n
, d
- 1, d
)
76 h
= hash_pre
+ h
+ hash_suf
80 class glx_pixel_function_stub(glX_XML
.glx_function
):
81 """Dummy class used to generate pixel "utility" functions that are
82 shared by multiple dimension image functions. For example, these
83 objects are used to generate shared functions used to send GLX
84 protocol for TexImage1D and TexImage2D, TexSubImage1D and
85 TexSubImage2D, etc."""
87 def __init__(self
, func
, name
):
88 # The parameters to the utility function are the same as the
89 # parameters to the real function except for the added "pad"
95 self
.parameters_by_name
= {}
96 for _p
in func
.parameterIterator():
98 self
.parameters
.append(p
)
99 self
.parameters_by_name
[ p
.name
] = p
103 self
.images
.append(p
)
106 if p
.img_yoff
== None:
107 p
.img_yoff
= "yoffset"
113 if p
.img_woff
== None:
114 p
.img_woff
= "woffset"
117 pad_name
= func
.pad_after(p
)
121 self
.parameters
.append(pad
)
122 self
.parameters_by_name
[ pad
.name
] = pad
125 self
.return_type
= func
.return_type
129 self
.glx_vendorpriv
= 0
131 self
.glx_doubles_in_order
= func
.glx_doubles_in_order
133 self
.vectorequiv
= None
135 self
.can_be_large
= func
.can_be_large
136 self
.reply_always_array
= func
.reply_always_array
137 self
.dimensions_in_reply
= func
.dimensions_in_reply
138 self
.img_reset
= None
140 self
.server_handcode
= 0
141 self
.client_handcode
= 0
144 self
.count_parameter_list
= func
.count_parameter_list
145 self
.counter_list
= func
.counter_list
146 self
.offsets_calculated
= 0
150 class PrintGlxProtoStubs(glX_proto_common
.glx_print_proto
):
152 glX_proto_common
.glx_print_proto
.__init
__(self
)
153 self
.name
= "glX_proto_send.py (from Mesa)"
154 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004, 2005", "IBM")
157 self
.last_category
= ""
158 self
.generic_sizes
= [3, 4, 6, 8, 12, 16, 24, 32]
159 self
.pixel_stubs
= {}
163 def printRealHeader(self
):
165 print '#include <GL/gl.h>'
166 print '#include "indirect.h"'
167 print '#include "glxclient.h"'
168 print '#include "indirect_size.h"'
169 print '#include "dispatch.h"'
170 print '#include "glthread.h"'
171 print '#include <GL/glxproto.h>'
172 print '#ifdef USE_XCB'
173 print '#include <X11/Xlib-xcb.h>'
174 print '#include <xcb/xcb.h>'
175 print '#include <xcb/glx.h>'
176 print '#endif /* USE_XCB */'
179 print '#define __GLX_PAD(n) (((n) + 3) & ~3)'
184 print '#if !defined __GNUC__ || __GNUC__ < 3'
185 print '# define __builtin_expect(x, y) x'
188 print '/* If the size and opcode values are known at compile-time, this will, on'
189 print ' * x86 at least, emit them with a single instruction.'
191 print '#define emit_header(dest, op, size) \\'
192 print ' do { union { short s[2]; int i; } temp; \\'
193 print ' temp.s[0] = (size); temp.s[1] = (op); \\'
194 print ' *((int *)(dest)) = temp.i; } while(0)'
196 print """NOINLINE CARD32
197 __glXReadReply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
199 xGLXSingleReply reply;
201 (void) _XReply(dpy, (xReply *) & reply, 0, False);
203 if ((reply.length > 0) || reply_is_always_array) {
204 const GLint bytes = (reply_is_always_array)
205 ? (4 * reply.length) : (reply.size * size);
206 const GLint extra = 4 - (bytes & 3);
208 _XRead(dpy, dest, bytes);
210 _XEatData(dpy, extra);
214 (void) memcpy( dest, &(reply.pad3), size);
222 __glXReadPixelReply( Display *dpy, __GLXcontext * gc, unsigned max_dim,
223 GLint width, GLint height, GLint depth, GLenum format, GLenum type,
224 void * dest, GLboolean dimensions_in_reply )
226 xGLXSingleReply reply;
229 (void) _XReply(dpy, (xReply *) & reply, 0, False);
231 if ( dimensions_in_reply ) {
236 if ((height == 0) || (max_dim < 2)) { height = 1; }
237 if ((depth == 0) || (max_dim < 3)) { depth = 1; }
240 size = reply.length * 4;
242 void * buf = Xmalloc( size );
245 _XEatData(dpy, size);
246 __glXSetError(gc, GL_OUT_OF_MEMORY);
249 const GLint extra = 4 - (size & 3);
251 _XRead(dpy, buf, size);
253 _XEatData(dpy, extra);
256 __glEmptyImage(gc, 3, width, height, depth, format, type,
263 #define X_GLXSingle 0
265 NOINLINE FASTCALL GLubyte *
266 __glXSetupSingleRequest( __GLXcontext * gc, GLint sop, GLint cmdlen )
269 Display * const dpy = gc->currentDpy;
271 (void) __glXFlushRenderBuffer(gc, gc->pc);
273 GetReqExtra(GLXSingle, cmdlen, req);
274 req->reqType = gc->majorOpcode;
275 req->contextTag = gc->currentContextTag;
277 return (GLubyte *)(req) + sz_xGLXSingleReq;
280 NOINLINE FASTCALL GLubyte *
281 __glXSetupVendorRequest( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
283 xGLXVendorPrivateReq * req;
284 Display * const dpy = gc->currentDpy;
286 (void) __glXFlushRenderBuffer(gc, gc->pc);
288 GetReqExtra(GLXVendorPrivate, cmdlen, req);
289 req->reqType = gc->majorOpcode;
291 req->vendorCode = vop;
292 req->contextTag = gc->currentContextTag;
293 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
296 const GLuint __glXDefaultPixelStore[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 1 };
298 #define zero (__glXDefaultPixelStore+0)
299 #define one (__glXDefaultPixelStore+8)
300 #define default_pixel_store_1D (__glXDefaultPixelStore+4)
301 #define default_pixel_store_1D_size 20
302 #define default_pixel_store_2D (__glXDefaultPixelStore+4)
303 #define default_pixel_store_2D_size 20
304 #define default_pixel_store_3D (__glXDefaultPixelStore+0)
305 #define default_pixel_store_3D_size 36
306 #define default_pixel_store_4D (__glXDefaultPixelStore+0)
307 #define default_pixel_store_4D_size 36
310 for size
in self
.generic_sizes
:
311 self
.print_generic_function(size
)
315 def printBody(self
, api
):
317 self
.pixel_stubs
= {}
320 for func
in api
.functionIterateGlx():
321 if func
.client_handcode
: continue
323 # If the function is a pixel function with a certain
324 # GLX protocol signature, create a fake stub function
325 # for it. For example, create a single stub function
326 # that is used to implement both glTexImage1D and
329 if func
.glx_rop
!= 0:
331 for image
in func
.get_images():
332 if image
.img_pad_dimensions
:
338 [h
, n
] = hash_pixel_function(func
)
341 self
.pixel_stubs
[ func
.name
] = n
342 if h
not in generated_stubs
:
343 generated_stubs
.append(h
)
345 fake_func
= glx_pixel_function_stub( func
, n
)
346 self
.printFunction(fake_func
, fake_func
.name
)
349 self
.printFunction(func
, func
.name
)
350 if func
.glx_sop
and func
.glx_vendorpriv
:
351 self
.printFunction(func
, func
.glx_vendorpriv_names
[0])
356 def printFunction(self
, func
, name
):
358 if func
.glx_rop
== ~
0:
359 print 'static %s' % (func
.return_type
)
360 print '%s( unsigned opcode, unsigned dim, %s )' % (func
.name
, func
.get_parameter_string())
363 if func
.has_different_protocol(name
):
364 if func
.return_type
== "void":
367 ret_string
= "return "
369 func_name
= func
.static_glx_name(name
)
370 print '#define %s %d' % (func
.opcode_vendor_name(name
), func
.glx_vendorpriv
)
371 print '%s gl%s(%s)' % (func
.return_type
, func_name
, func
.get_parameter_string())
373 print ' __GLXcontext * const gc = __glXGetCurrentContext();'
375 print ' if (gc->isDirect) {'
376 print ' %sCALL_%s(GET_DISPATCH(), (%s));' % (ret_string
, func
.name
, func
.get_called_parameter_string())
380 print '#define %s %d' % (func
.opcode_name(), func
.opcode_value())
382 print '%s __indirect_gl%s(%s)' % (func
.return_type
, name
, func
.get_parameter_string())
386 if func
.glx_rop
!= 0 or func
.vectorequiv
!= None:
388 self
.printPixelFunction(func
)
390 self
.printRenderFunction(func
)
391 elif func
.glx_sop
!= 0 or func
.glx_vendorpriv
!= 0:
392 self
.printSingleFunction(func
, name
)
395 print "/* Missing GLX protocol for %s. */" % (name
)
401 def print_generic_function(self
, n
):
403 print """static FASTCALL NOINLINE void
404 generic_%u_byte( GLint rop, const void * ptr )
406 __GLXcontext * const gc = __glXGetCurrentContext();
407 const GLuint cmdlen = %u;
409 emit_header(gc->pc, rop, cmdlen);
410 (void) memcpy((void *)(gc->pc + 4), ptr, %u);
412 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
414 """ % (n
, size
+ 4, size
)
418 def common_emit_one_arg(self
, p
, pc
, adjust
, extra_offset
):
422 src_ptr
= "&" + p
.name
425 print '(void) memcpy((void *)(%s + %u), (void *)(%s), %s);' \
426 % (pc
, p
.offset
+ adjust
, src_ptr
, p
.size_string() )
428 print '(void) memcpy((void *)(%s + %u + %s), (void *)(%s), %s);' \
429 % (pc
, p
.offset
+ adjust
, extra_offset
, src_ptr
, p
.size_string() )
431 def common_emit_args(self
, f
, pc
, adjust
, skip_vla
):
434 for p
in f
.parameterIterateGlxSend( not skip_vla
):
435 if p
.name
!= f
.img_reset
:
436 self
.common_emit_one_arg(p
, pc
, adjust
, extra_offset
)
438 if p
.is_variable_length():
439 temp
= p
.size_string()
441 extra_offset
+= " + %s" % (temp
)
448 def pixel_emit_args(self
, f
, pc
, large
):
449 """Emit the arguments for a pixel function. This differs from
450 common_emit_args in that pixel functions may require padding
451 be inserted (i.e., for the missing width field for
452 TexImage1D), and they may also require a 'NULL image' flag
453 be inserted before the image data."""
460 for param
in f
.parameterIterateGlxSend():
461 if not param
.is_image():
462 self
.common_emit_one_arg(param
, pc
, adjust
, None)
464 if f
.pad_after(param
):
465 print '(void) memcpy((void *)(%s + %u), zero, 4);' % (pc
, (param
.offset
+ param
.size()) + adjust
)
468 [dim
, width
, height
, depth
, extent
] = param
.get_dimensions()
474 if param
.img_null_flag
:
476 print '(void) memcpy((void *)(%s + %u), zero, 4);' % (pc
, (param
.offset
- 4) + adjust
)
478 print '(void) memcpy((void *)(%s + %u), (void *)((%s == NULL) ? one : zero), 4);' % (pc
, (param
.offset
- 4) + adjust
, param
.name
)
481 pixHeaderPtr
= "%s + %u" % (pc
, adjust
)
482 pcPtr
= "%s + %u" % (pc
, param
.offset
+ adjust
)
485 if param
.img_send_null
:
486 condition
= '(compsize > 0) && (%s != NULL)' % (param
.name
)
488 condition
= 'compsize > 0'
490 print 'if (%s) {' % (condition
)
491 print ' (*gc->fillImage)(gc, %s, %s, %s, %s, %s, %s, %s, %s, %s);' % (dim_str
, width
, height
, depth
, param
.img_format
, param
.img_type
, param
.name
, pcPtr
, pixHeaderPtr
)
493 print ' (void) memcpy( %s, default_pixel_store_%uD, default_pixel_store_%uD_size );' % (pixHeaderPtr
, dim
, dim
)
496 print '__glXSendLargeImage(gc, compsize, %s, %s, %s, %s, %s, %s, %s, %s, %s);' % (dim_str
, width
, height
, depth
, param
.img_format
, param
.img_type
, param
.name
, pcPtr
, pixHeaderPtr
)
501 def large_emit_begin(self
, f
, op_name
= None):
503 op_name
= f
.opcode_real_name()
505 print 'const GLint op = %s;' % (op_name
)
506 print 'const GLuint cmdlenLarge = cmdlen + 4;'
507 print 'GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);'
508 print '(void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);'
509 print '(void) memcpy((void *)(pc + 4), (void *)(&op), 4);'
513 def common_func_print_just_start(self
, f
):
514 print ' __GLXcontext * const gc = __glXGetCurrentContext();'
516 # The only reason that single and vendor private commands need
517 # a variable called 'dpy' is becuase they use the SyncHandle
518 # macro. For whatever brain-dead reason, that macro is hard-
519 # coded to use a variable called 'dpy' instead of taking a
522 # FIXME Simplify the logic related to skip_condition and
523 # FIXME condition_list in this function. Basically, remove
524 # FIXME skip_condition, and just append the "dpy != NULL" type
525 # FIXME condition to condition_list from the start. The only
526 # FIXME reason it's done in this confusing way now is to
527 # FIXME minimize the diffs in the generated code.
530 for p
in f
.parameterIterateOutputs():
532 print ' const __GLXattribute * const state = gc->client_state_private;'
535 print ' Display * const dpy = gc->currentDpy;'
536 skip_condition
= "dpy != NULL"
538 skip_condition
= "gc->currentDpy != NULL"
540 skip_condition
= None
543 if f
.return_type
!= 'void':
544 print ' %s retval = (%s) 0;' % (f
.return_type
, f
.return_type
)
547 self
.emit_packet_size_calculation(f
, 0)
550 for p
in f
.parameterIterateCounters():
551 condition_list
.append( "%s >= 0" % (p
.name
) )
554 condition_list
.append( skip_condition
)
556 if len( condition_list
) > 0:
557 if len( condition_list
) > 1:
558 skip_condition
= "(%s)" % (string
.join( condition_list
, ") && (" ))
560 skip_condition
= "%s" % (condition_list
.pop(0))
562 print ' if (__builtin_expect(%s, 1)) {' % (skip_condition
)
568 def printSingleFunction(self
, f
, name
):
569 self
.common_func_print_just_start(f
)
572 print ' printf( "Enter %%s...\\n", "gl%s" );' % (f
.name
)
574 if name
not in f
.glx_vendorpriv_names
:
577 print '#ifdef USE_XCB'
579 print ' printf("\\tUsing XCB.\\n");'
580 print ' xcb_connection_t *c = XGetXCBConnection(dpy);'
581 print ' (void) __glXFlushRenderBuffer(gc, gc->pc);'
582 xcb_name
= 'xcb_glx%s' % convertStringForXCB(name
)
587 for p
in f
.parameterIterator():
592 if p
.img_format
!= "GL_COLOR_INDEX" or p
.img_type
!= "GL_BITMAP":
593 extra_iparams
.append("state->storePack.swapEndian")
595 extra_iparams
.append("0")
597 # Hardcode this in. lsb_first param (apparently always GL_FALSE)
598 # also present in GetPolygonStipple, but taken care of above.
599 if xcb_name
== "xcb_glx_read_pixels":
600 extra_iparams
.append("0")
602 iparams
.append(p
.name
)
605 xcb_request
= '%s(%s)' % (xcb_name
, ", ".join(["c", "gc->currentContextTag"] + iparams
+ extra_iparams
))
608 print ' %s_reply_t *reply = %s_reply(c, %s, NULL);' % (xcb_name
, xcb_name
, xcb_request
)
609 if output
and f
.reply_always_array
:
610 print ' (void)memcpy(%s, %s_data(reply), %s_data_length(reply) * sizeof(%s));' % (output
.name
, xcb_name
, xcb_name
, output
.get_base_type_string())
612 elif output
and not f
.reply_always_array
:
613 if not output
.is_image():
614 print ' if (%s_data_length(reply) == 0)' % (xcb_name
)
615 print ' (void)memcpy(%s, &reply->datum, sizeof(reply->datum));' % (output
.name
)
617 print ' (void)memcpy(%s, %s_data(reply), %s_data_length(reply) * sizeof(%s));' % (output
.name
, xcb_name
, xcb_name
, output
.get_base_type_string())
620 if f
.return_type
!= 'void':
621 print ' retval = reply->ret_val;'
622 print ' free(reply);'
624 print ' ' + xcb_request
+ ';'
626 # End of XCB specific.
629 if f
.parameters
!= []:
630 pc_decl
= "GLubyte const * pc ="
634 if name
in f
.glx_vendorpriv_names
:
635 print ' %s __glXSetupVendorRequest(gc, %s, %s, cmdlen);' % (pc_decl
, f
.opcode_real_name(), f
.opcode_vendor_name(name
))
637 print ' %s __glXSetupSingleRequest(gc, %s, cmdlen);' % (pc_decl
, f
.opcode_name())
639 self
.common_emit_args(f
, "pc", 0, 0)
641 images
= f
.get_images()
645 o
= f
.command_fixed_length() - 4
646 print ' *(int32_t *)(pc + %u) = 0;' % (o
)
647 if img
.img_format
!= "GL_COLOR_INDEX" or img
.img_type
!= "GL_BITMAP":
648 print ' * (int8_t *)(pc + %u) = state->storePack.swapEndian;' % (o
)
651 print ' * (int8_t *)(pc + %u) = %s;' % (o
+ 1, f
.img_reset
)
656 if f
.return_type
!= 'void':
657 return_name
= " retval"
658 return_str
= " retval = (%s)" % (f
.return_type
)
660 return_str
= " (void)"
664 for p
in f
.parameterIterateOutputs():
666 [dim
, w
, h
, d
, junk
] = p
.get_dimensions()
667 if f
.dimensions_in_reply
:
668 print " __glXReadPixelReply(dpy, gc, %u, 0, 0, 0, %s, %s, %s, GL_TRUE);" % (dim
, p
.img_format
, p
.img_type
, p
.name
)
670 print " __glXReadPixelReply(dpy, gc, %u, %s, %s, %s, %s, %s, %s, GL_FALSE);" % (dim
, w
, h
, d
, p
.img_format
, p
.img_type
, p
.name
)
674 if f
.reply_always_array
:
679 # gl_parameter.size() returns the size
680 # of the entire data item. If the
681 # item is a fixed-size array, this is
682 # the size of the whole array. This
683 # is not what __glXReadReply wants. It
684 # wants the size of a single data
685 # element in the reply packet.
686 # Dividing by the array size (1 for
687 # non-arrays) gives us this.
689 s
= p
.size() / p
.get_element_count()
690 print " %s __glXReadReply(dpy, %s, %s, %s);" % (return_str
, s
, p
.name
, aa
)
694 # If a reply wasn't read to fill an output parameter,
695 # read a NULL reply to get the return value.
698 print " %s __glXReadReply(dpy, 0, NULL, GL_FALSE);" % (return_str
)
702 # Only emit the extra glFinish call for functions
703 # that don't already require a reply from the server.
704 print ' __indirect_glFinish();'
707 print ' printf( "Exit %%s.\\n", "gl%s" );' % (name
)
710 print ' UnlockDisplay(dpy); SyncHandle();'
712 if name
not in f
.glx_vendorpriv_names
:
713 print '#endif /* USE_XCB */'
716 print ' return%s;' % (return_name
)
720 def printPixelFunction(self
, f
):
721 if self
.pixel_stubs
.has_key( f
.name
):
722 # Normally gl_function::get_parameter_string could be
723 # used. However, this call needs to have the missing
724 # dimensions (e.g., a fake height value for
725 # glTexImage1D) added in.
728 for param
in f
.parameterIterateGlxSend():
729 p_string
+= ", " + param
.name
732 [dim
, junk
, junk
, junk
, junk
] = param
.get_dimensions()
734 if f
.pad_after(param
):
737 print ' %s(%s, %u%s );' % (self
.pixel_stubs
[f
.name
] , f
.opcode_name(), dim
, p_string
)
741 if self
.common_func_print_just_start(f
):
748 print 'if (cmdlen <= gc->maxSmallRenderCommandSize) {'
749 print ' if ( (gc->pc + cmdlen) > gc->bufEnd ) {'
750 print ' (void) __glXFlushRenderBuffer(gc, gc->pc);'
756 opcode
= f
.opcode_real_name()
758 print 'emit_header(gc->pc, %s, cmdlen);' % (opcode
)
760 self
.pixel_emit_args( f
, "gc->pc", 0 )
761 print 'gc->pc += cmdlen;'
762 print 'if (gc->pc > gc->limit) { (void) __glXFlushRenderBuffer(gc, gc->pc); }'
768 self
.large_emit_begin(f
, opcode
)
769 self
.pixel_emit_args(f
, "pc", 1)
773 if trailer
: print trailer
777 def printRenderFunction(self
, f
):
778 # There is a class of GL functions that take a single pointer
779 # as a parameter. This pointer points to a fixed-size chunk
780 # of data, and the protocol for this functions is very
781 # regular. Since they are so regular and there are so many
782 # of them, special case them with generic functions. On
783 # x86, this saves about 26KB in the libGL.so binary.
785 if f
.variable_length_parameter() == None and len(f
.parameters
) == 1:
788 cmdlen
= f
.command_fixed_length()
789 if cmdlen
in self
.generic_sizes
:
790 print ' generic_%u_byte( %s, %s );' % (cmdlen
, f
.opcode_real_name(), p
.name
)
793 if self
.common_func_print_just_start(f
):
799 print 'printf( "Enter %%s...\\n", "gl%s" );' % (f
.name
)
802 print 'if (cmdlen <= gc->maxSmallRenderCommandSize) {'
803 print ' if ( (gc->pc + cmdlen) > gc->bufEnd ) {'
804 print ' (void) __glXFlushRenderBuffer(gc, gc->pc);'
807 print 'emit_header(gc->pc, %s, cmdlen);' % (f
.opcode_real_name())
809 self
.common_emit_args(f
, "gc->pc", 4, 0)
810 print 'gc->pc += cmdlen;'
811 print 'if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }'
817 self
.large_emit_begin(f
)
818 self
.common_emit_args(f
, "pc", 8, 1)
820 p
= f
.variable_length_parameter()
821 print ' __glXSendLargeCommand(gc, pc, %u, %s, %s);' % (p
.offset
+ 8, p
.name
, p
.size_string())
825 print '__indirect_glFinish();'
826 print 'printf( "Exit %%s.\\n", "gl%s" );' % (f
.name
)
828 if trailer
: print trailer
832 class PrintGlxProtoInit_c(gl_XML
.gl_print_base
):
834 gl_XML
.gl_print_base
.__init
__(self
)
836 self
.name
= "glX_proto_send.py (from Mesa)"
837 self
.license
= license
.bsd_license_template
% ( \
838 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
839 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
843 def printRealHeader(self
):
845 * \\file indirect_init.c
846 * Initialize indirect rendering dispatch table.
848 * \\author Kevin E. Martin <kevin@precisioninsight.com>
849 * \\author Brian Paul <brian@precisioninsight.com>
850 * \\author Ian Romanick <idr@us.ibm.com>
853 #include "indirect_init.h"
854 #include "indirect.h"
859 * No-op function used to initialize functions that have no GLX protocol
862 static int NoOp(void)
868 * Create and initialize a new GL dispatch table. The table is initialized
869 * with GLX indirect rendering protocol functions.
871 __GLapi * __glXNewIndirectAPI( void )
876 entries = _glapi_get_dispatch_table_size();
877 glAPI = (__GLapi *) Xmalloc(entries * sizeof(void *));
879 /* first, set all entries to point to no-op functions */
882 void **dispatch = (void **) glAPI;
883 for (i = 0; i < entries; i++) {
884 dispatch[i] = (void *) NoOp;
888 /* now, initialize the entries we understand */"""
890 def printRealFooter(self
):
898 def printBody(self
, api
):
899 for [name
, number
] in api
.categoryIterate():
901 preamble
= '\n /* %3u. %s */\n\n' % (int(number
), name
)
903 preamble
= '\n /* %s */\n\n' % (name
)
905 for func
in api
.functionIterateByCategory(name
):
906 if func
.client_supported_for_indirect():
907 print '%s glAPI->%s = __indirect_gl%s;' % (preamble
, func
.name
, func
.name
)
913 class PrintGlxProtoInit_h(gl_XML
.gl_print_base
):
915 gl_XML
.gl_print_base
.__init
__(self
)
917 self
.name
= "glX_proto_send.py (from Mesa)"
918 self
.license
= license
.bsd_license_template
% ( \
919 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
920 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
921 self
.header_tag
= "_INDIRECT_H_"
923 self
.last_category
= ""
927 def printRealHeader(self
):
930 * Prototypes for indirect rendering functions.
932 * \\author Kevin E. Martin <kevin@precisioninsight.com>
933 * \\author Ian Romanick <idr@us.ibm.com>
936 self
.printVisibility( "HIDDEN", "hidden" )
941 #include "glxclient.h"
943 extern HIDDEN NOINLINE CARD32 __glXReadReply( Display *dpy, size_t size,
944 void * dest, GLboolean reply_is_always_array );
946 extern HIDDEN NOINLINE void __glXReadPixelReply( Display *dpy,
947 __GLXcontext * gc, unsigned max_dim, GLint width, GLint height,
948 GLint depth, GLenum format, GLenum type, void * dest,
949 GLboolean dimensions_in_reply );
951 extern HIDDEN NOINLINE FASTCALL GLubyte * __glXSetupSingleRequest(
952 __GLXcontext * gc, GLint sop, GLint cmdlen );
954 extern HIDDEN NOINLINE FASTCALL GLubyte * __glXSetupVendorRequest(
955 __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen );
959 def printBody(self
, api
):
960 for func
in api
.functionIterateGlx():
961 params
= func
.get_parameter_string()
963 print 'extern HIDDEN %s __indirect_gl%s(%s);' % (func
.return_type
, func
.name
, params
)
965 for n
in func
.entry_points
:
966 if func
.has_different_protocol(n
):
967 asdf
= func
.static_glx_name(n
)
968 if asdf
not in func
.static_entry_points
:
969 print 'extern HIDDEN %s gl%s(%s);' % (func
.return_type
, asdf
, params
)
971 print 'GLAPI %s GLAPIENTRY gl%s(%s);' % (func
.return_type
, asdf
, params
)
978 print "Usage: %s [-f input_file_name] [-m output_mode] [-d]" % sys
.argv
[0]
979 print " -m output_mode Output mode can be one of 'proto', 'init_c' or 'init_h'."
980 print " -d Enable extra debug information in the generated code."
984 if __name__
== '__main__':
985 file_name
= "gl_API.xml"
988 (args
, trail
) = getopt
.getopt(sys
.argv
[1:], "f:m:d")
994 for (arg
,val
) in args
:
1003 printer
= PrintGlxProtoStubs()
1004 elif mode
== "init_c":
1005 printer
= PrintGlxProtoInit_c()
1006 elif mode
== "init_h":
1007 printer
= PrintGlxProtoInit_h()
1012 printer
.debug
= debug
1013 api
= gl_XML
.parse_GL_API( file_name
, glX_XML
.glx_item_factory() )
1015 printer
.Print( api
)