3 # (C) Copyright IBM Corporation 2004
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 from xml
.sax
import saxutils
29 from xml
.sax
import make_parser
30 from xml
.sax
.handler
import feature_namespaces
38 class PrintGlxProtoStubs(glX_XML
.GlxProto
):
40 glX_XML
.GlxProto
.__init
__(self
)
41 self
.last_category
= ""
42 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
43 self
.generic_sizes
= [3, 4, 6, 8, 12, 16, 24, 32]
46 def printRealHeader(self
):
48 print '#include <GL/gl.h>'
49 print '#include "indirect.h"'
50 print '#include "glxclient.h"'
51 print '#include "size.h"'
52 print '#include <GL/glxproto.h>'
54 print '#define __GLX_PAD(n) (((n) + 3) & ~3)'
56 glX_XML
.printFastcall()
57 glX_XML
.printNoinline()
59 print '#if !defined __GNUC__ || __GNUC__ < 3'
60 print '# define __builtin_expect(x, y) x'
63 print '/* If the size and opcode values are known at compile-time, this will, on'
64 print ' * x86 at least, emit them with a single instruction.'
66 print '#define emit_header(dest, op, size) \\'
67 print ' do { union { short s[2]; int i; } temp; \\'
68 print ' temp.s[0] = (size); temp.s[1] = (op); \\'
69 print ' *((int *)(dest)) = temp.i; } while(0)'
71 print """static NOINLINE CARD32
72 read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
74 xGLXSingleReply reply;
76 (void) _XReply(dpy, (xReply *) & reply, 0, False);
78 if ((reply.length > 0) || reply_is_always_array) {
79 const GLint bytes = (reply_is_always_array)
80 ? (4 * reply.length) : (reply.size * size);
81 const GLint extra = 4 - (bytes & 3);
83 _XRead(dpy, dest, bytes);
85 _XEatData(dpy, extra);
89 (void) memcpy( dest, &(reply.pad3), size);
98 static NOINLINE FASTCALL GLubyte *
99 setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
102 Display * const dpy = gc->currentDpy;
104 (void) __glXFlushRenderBuffer(gc, gc->pc);
106 GetReqExtra(GLXSingle, cmdlen, req);
107 req->reqType = gc->majorOpcode;
108 req->contextTag = gc->currentContextTag;
110 return (GLubyte *)(req) + sz_xGLXSingleReq;
113 static NOINLINE FASTCALL GLubyte *
114 setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
116 xGLXVendorPrivateReq * req;
117 Display * const dpy = gc->currentDpy;
119 (void) __glXFlushRenderBuffer(gc, gc->pc);
121 GetReqExtra(GLXVendorPrivate, cmdlen, req);
122 req->reqType = gc->majorOpcode;
124 req->vendorCode = vop;
125 req->contextTag = gc->currentContextTag;
126 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
130 for size
in self
.generic_sizes
:
131 self
.print_generic_function(size
)
134 def printFunction(self
, f
):
135 if f
.fn_offset
< 0 or f
.handcode
or f
.ignore
: return
137 if f
.glx_rop
!= 0 or f
.vectorequiv
!= None:
138 self
.printRenderFunction(f
)
139 elif f
.glx_sop
!= 0 or f
.glx_vendorpriv
!= 0:
140 self
.printSingleFunction(f
)
142 print "/* Missing GLX protocol for %s. */" % (f
.name
)
144 def print_generic_function(self
, n
):
145 print """static FASTCALL NOINLINE void
146 generic_%u_byte( GLint rop, const void * ptr )
148 __GLXcontext * const gc = __glXGetCurrentContext();
149 const GLuint cmdlen = %u;
151 emit_header(gc->pc, rop, cmdlen);
152 (void) memcpy((void *)(gc->pc + 4), ptr, %u);
154 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
159 def common_emit_one_arg(self
, p
, offset
, pc
, indent
, adjust
):
164 src_ptr
= "&" + p
.name
166 print '%s (void) memcpy((void *)(%s + %u), (void *)(%s), %s);' \
167 % (indent
, pc
, offset
+ adjust
, src_ptr
, p
.size_string() )
169 def common_emit_args(self
, f
, pc
, indent
, adjust
, skip_vla
):
177 for p
in f
.parameterIterator(1, r
):
178 self
.common_emit_one_arg(p
, offset
, pc
, indent
, adjust
)
184 def common_func_print_just_header(self
, f
):
185 print '#define %s %d' % (f
.opcode_name(), f
.opcode_value())
187 print '%s' % (f
.fn_return_type
)
188 print '__indirect_gl%s(%s)' % (f
.name
, f
.get_parameter_string())
192 def common_func_print_header(self
, f
):
193 self
.common_func_print_just_header(f
)
195 print ' __GLXcontext * const gc = __glXGetCurrentContext();'
197 # The only reason that single and vendor private commands need
198 # a variable called 'dpy' is becuase they use the SyncHandle
199 # macro. For whatever brain-dead reason, that macro is hard-
200 # coded to use a variable called 'dpy' instead of taking a
204 print ' Display * const dpy = gc->currentDpy;'
205 skip_condition
= "dpy != NULL"
207 skip_condition
= "gc->currentDpy != NULL"
209 skip_condition
= None
212 if f
.fn_return_type
!= 'void':
213 print ' %s retval = (%s) 0;' % (f
.fn_return_type
, f
.fn_return_type
)
215 if f
.count_parameters
!= None:
216 print ' const GLuint compsize = __gl%s_size(%s);' % (f
.name
, f
.count_parameters
)
218 print ' const GLuint cmdlen = %s;' % (f
.command_length())
222 skip_condition
= "(%s >= 0) && (%s)" % (f
.counter
, skip_condition
)
224 skip_condition
= "%s >= 0" % (f
.counter
)
228 print ' if (__builtin_expect(%s, 1)) {' % (skip_condition
)
234 def printSingleFunction(self
, f
):
235 self
.common_func_print_header(f
)
237 if f
.fn_parameters
!= []:
238 pc_decl
= "GLubyte const * pc ="
242 if f
.glx_vendorpriv
!= 0:
243 print ' %s setup_vendor_request(gc, %s, %s, cmdlen);' % (pc_decl
, f
.opcode_real_name(), f
.opcode_name())
245 print ' %s setup_single_request(gc, %s, cmdlen);' % (pc_decl
, f
.opcode_name())
247 self
.common_emit_args(f
, "pc", " ", 0, 0)
251 output_size
= f
.output
.p_type
.size
252 output_str
= f
.output
.name
257 if f
.fn_return_type
!= 'void':
258 return_str
= " retval = (%s)" % (f
.fn_return_type
)
260 return_str
= " (void)"
262 if f
.reply_always_array
:
267 print " %s read_reply(dpy, %s, %s, %s);" % (return_str
, output_size
, output_str
, aa
)
269 print ' UnlockDisplay(dpy); SyncHandle();'
271 print ' %s' % f
.return_string()
277 def printRenderFunction(self
, f
):
278 # There is a class of GL functions that take a single pointer
279 # as a parameter. This pointer points to a fixed-size chunk
280 # of data, and the protocol for this functions is very
281 # regular. Since they are so regular and there are so many
282 # of them, special case them with generic functions. On
283 # x86, this saves about 26KB in the libGL.so binary.
285 if f
.variable_length_parameter() == None and len(f
.fn_parameters
) == 1:
286 p
= f
.fn_parameters
[0]
288 [cmdlen
, size_string
] = f
.command_payload_length()
289 if cmdlen
in self
.generic_sizes
:
290 self
.common_func_print_just_header(f
)
291 print ' generic_%u_byte( %s, %s );' % (cmdlen
, f
.opcode_real_name(), p
.name
)
296 if self
.common_func_print_header(f
):
304 print '%s if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent
)
305 print '%s if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent
)
306 print '%s (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent
)
307 print '%s }' % (indent
)
310 print '%s emit_header(gc->pc, %s, cmdlen);' % (indent
, f
.opcode_real_name())
312 self
.common_emit_args(f
, "gc->pc", indent
, 4, 0)
313 print '%s gc->pc += cmdlen;' % (indent
)
314 print '%s if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent
)
317 print '%s}' % (indent
)
318 print '%selse {' % (indent
)
319 print '%s const GLint op = %s;' % (indent
, f
.opcode_real_name())
320 print '%s const GLuint cmdlenLarge = cmdlen + 4;' % (indent
)
321 print '%s GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);' % (indent
)
322 print '%s (void) memcpy((void *)(pc + 0), (void *)(&op), 4);' % (indent
)
323 print '%s (void) memcpy((void *)(pc + 4), (void *)(&cmdlenLarge), 4);' % (indent
)
324 offset
= self
.common_emit_args(f
, "pc", indent
, 8, 1)
326 p
= f
.variable_length_parameter()
327 print '%s __glXSendLargeCommand(gc, pc, %u, %s, %s);' % (indent
, offset
+ 8, p
.name
, p
.size_string())
328 print '%s}' % (indent
)
330 if trailer
: print trailer
336 class PrintGlxProtoInit_c(glX_XML
.GlxProto
):
338 glX_XML
.GlxProto
.__init
__(self
)
339 self
.last_category
= ""
340 self
.license
= license
.bsd_license_template
% ( \
341 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
342 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
345 def printRealHeader(self
):
347 * \\file indirect_init.c
348 * Initialize indirect rendering dispatch table.
350 * \\author Kevin E. Martin <kevin@precisioninsight.com>
351 * \\author Brian Paul <brian@precisioninsight.com>
352 * \\author Ian Romanick <idr@us.ibm.com>
355 #include "indirect_init.h"
356 #include "indirect.h"
361 * No-op function used to initialize functions that have no GLX protocol
364 static int NoOp(void)
370 * Create and initialize a new GL dispatch table. The table is initialized
371 * with GLX indirect rendering protocol functions.
373 __GLapi * __glXNewIndirectAPI( void )
378 entries = _glapi_get_dispatch_table_size();
379 glAPI = (__GLapi *) Xmalloc(entries * sizeof(void *));
381 /* first, set all entries to point to no-op functions */
384 void **dispatch = (void **) glAPI;
385 for (i = 0; i < entries; i++) {
386 dispatch[i] = (void *) NoOp;
390 /* now, initialize the entries we understand */"""
392 def printRealFooter(self
):
398 def printFunction(self
, f
):
399 if f
.fn_offset
< 0 or f
.ignore
: return
401 if f
.category
!= self
.last_category
:
402 self
.last_category
= f
.category
404 print ' /* %s */' % (self
.last_category
)
407 print ' glAPI->%s = __indirect_gl%s;' % (f
.name
, f
.name
)
410 class PrintGlxProtoInit_h(glX_XML
.GlxProto
):
412 glX_XML
.GlxProto
.__init
__(self
)
413 self
.last_category
= ""
414 self
.license
= license
.bsd_license_template
% ( \
415 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
416 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
419 def printRealHeader(self
):
423 * Prototypes for indirect rendering functions.
425 * \\author Kevin E. Martin <kevin@precisioninsight.com>
426 * \\author Ian Romanick <idr@us.ibm.com>
429 #if !defined( _INDIRECT_H_ )
430 # define _INDIRECT_H_
433 glX_XML
.printVisibility( "HIDDEN", "hidden" )
436 def printRealFooter(self
):
437 print "# undef HIDDEN"
438 print "#endif /* !defined( _INDIRECT_H_ ) */"
440 def printFunction(self
, f
):
441 if f
.fn_offset
< 0 or f
.ignore
: return
442 print 'extern HIDDEN %s __indirect_gl%s(%s);' % (f
.fn_return_type
, f
.name
, f
.get_parameter_string())
445 class PrintGlxSizeStubs(glX_XML
.GlxProto
):
447 glX_XML
.GlxProto
.__init
__(self
)
448 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
450 self
.glx_enum_sigs
= {}
452 def printRealHeader(self
):
454 print '#include <GL/gl.h>'
455 print '#include "indirect_size.h"'
460 glX_XML
.printFastcall()
462 glX_XML
.printVisibility( "INTERNAL", "internal" )
465 print '#ifdef HAVE_ALIAS'
466 print '# define ALIAS2(from,to) \\'
467 print ' INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \\'
468 print ' __attribute__ ((alias( # to )));'
469 print '# define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size )'
471 print '# define ALIAS(from,to) \\'
472 print ' INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \\'
473 print ' { return __gl ## to ## _size( e ); }'
478 def printRealFooter(self
):
479 for a
in self
.aliases
:
482 def printFunction(self
, f
):
483 if self
.glx_enum_functions
.has_key(f
.name
):
484 ef
= self
.glx_enum_functions
[f
.name
]
486 sig
= ef
.signature();
487 if self
.glx_enum_sigs
.has_key(sig
):
488 n
= self
.glx_enum_sigs
[sig
];
489 a
= 'ALIAS( %s, %s )' % (f
.name
, n
)
490 self
.aliases
.append(a
)
493 self
.glx_enum_sigs
[sig
] = f
.name
;
497 class PrintGlxSizeStubs_h(glX_XML
.GlxProto
):
499 glX_XML
.GlxProto
.__init
__(self
)
500 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
502 self
.glx_enum_sigs
= {}
504 def printRealHeader(self
):
508 * Prototypes for functions used to determine the number of data elements in
509 * various GLX protocol messages.
511 * \\author Ian Romanick <idr@us.ibm.com>
514 #if !defined( _GLXSIZE_H_ )
520 glX_XML
.printFastcall();
522 glX_XML
.printVisibility( "INTERNAL", "internal" );
525 def printRealFooter(self
):
527 print "# undef INTERNAL"
529 print "# undef FASTCALL"
530 print "#endif /* !defined( _GLXSIZE_H_ ) */"
533 def printFunction(self
, f
):
534 if self
.glx_enum_functions
.has_key(f
.name
):
535 ef
= self
.glx_enum_functions
[f
.name
]
536 print 'extern INTERNAL PURE FASTCALL GLint __gl%s_size(GLenum);' % (f
.name
)
540 print "Usage: %s [-f input_file_name] [-m output_mode]" % sys
.argv
[0]
544 if __name__
== '__main__':
545 file_name
= "gl_API.xml"
548 (args
, trail
) = getopt
.getopt(sys
.argv
[1:], "f:m:")
553 for (arg
,val
) in args
:
560 dh
= PrintGlxProtoStubs()
561 elif mode
== "init_c":
562 dh
= PrintGlxProtoInit_c()
563 elif mode
== "init_h":
564 dh
= PrintGlxProtoInit_h()
565 elif mode
== "size_c":
566 dh
= PrintGlxSizeStubs()
567 elif mode
== "size_h":
568 dh
= PrintGlxSizeStubs_h()
572 parser
= make_parser()
573 parser
.setFeature(feature_namespaces
, 0)
574 parser
.setContentHandler(dh
)