src/mesa/glapi/glX_XML.py

   1 #!/usr/bin/python2
   2
   3 # (C) Copyright IBM Corporation 2004, 2005
   4 # All Rights Reserved.
   5 #
   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:
  12 #
  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
  15 # Software.
  16 #
  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
  23 # IN THE SOFTWARE.
  24 #
  25 # Authors:
  26 #    Ian Romanick <idr@us.ibm.com>
  27
  28 from xml.sax import saxutils
  29 from xml.sax import make_parser
  30 from xml.sax.handler import feature_namespaces
  31
  32 import gl_XML
  33 import license
  34 import sys, getopt
  35
  36
  37 class glXItemFactory(gl_XML.glItemFactory):
  38         """Factory to create GLX protocol oriented objects derived from glItem."""
  39
  40         def create(self, context, name, attrs):
  41                 if name == "function":
  42                         return glXFunction(context, name, attrs)
  43                 elif name == "enum":
  44                         return glXEnum(context, name, attrs)
  45                 elif name == "param":
  46                         return glXParameter(context, name, attrs)
  47                 else:
  48                         return gl_XML.glItemFactory.create(self, context, name, attrs)
  49
  50 class glXEnumFunction:
  51         def __init__(self, name, context):
  52                 self.name = name
  53                 self.context = context
  54                 self.mode = 0
  55                 self.sig = None
  56
  57                 # "enums" is a set of lists.  The element in the set is the
  58                 # value of the enum.  The list is the list of names for that
  59                 # value.  For example, [0x8126] = {"POINT_SIZE_MIN",
  60                 # "POINT_SIZE_MIN_ARB", "POINT_SIZE_MIN_EXT",
  61                 # "POINT_SIZE_MIN_SGIS"}.
  62
  63                 self.enums = {}
  64
  65                 # "count" is indexed by count values.  Each element of count
  66                 # is a list of index to "enums" that have that number of
  67                 # associated data elements.  For example, [4] =
  68                 # {GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION,
  69                 # GL_AMBIENT_AND_DIFFUSE} (the enum names are used here,
  70                 # but the actual hexadecimal values would be in the array).
  71
  72                 self.count = {}
  73
  74
  75         def append(self, count, value, name):
  76                 if self.enums.has_key( value ):
  77                         self.enums[value].append(name)
  78                 else:
  79                         if not self.count.has_key(count):
  80                                 self.count[count] = []
  81
  82                         self.enums[value] = []
  83                         self.enums[value].append(name)
  84                         self.count[count].append(value)
  85
  86
  87         def signature( self ):
  88                 if self.sig == None:
  89                         self.sig = ""
  90                         for i in self.count:
  91                                 self.count[i].sort()
  92                                 for e in self.count[i]:
  93                                         self.sig += "%04x,%u," % (e, i)
  94
  95                 return self.sig
  96
  97
  98         def set_mode( self, mode ):
  99                 """Mark an enum-function as a 'set' function."""
 100
 101                 self.mode = mode
 102
 103
 104         def is_set( self ):
 105                 return self.mode
 106
 107
 108         def PrintUsingTable(self):
 109                 """Emit the body of the __gl*_size function using a pair
 110                 of look-up tables and a mask.  The mask is calculated such
 111                 that (e & mask) is unique for all the valid values of e for
 112                 this function.  The result of (e & mask) is used as an index
 113                 into the first look-up table.  If it matches e, then the
 114                 same entry of the second table is returned.  Otherwise zero
 115                 is returned.
 116
 117                 It seems like this should cause better code to be generated.
 118                 However, on x86 at least, the resulting .o file is about 20%
 119                 larger then the switch-statment version.  I am leaving this
 120                 code in because the results may be different on other
 121                 platforms (e.g., PowerPC or x86-64)."""
 122
 123                 return 0
 124                 count = 0
 125                 for a in self.enums:
 126                         count += 1
 127
 128                 # Determine if there is some mask M, such that M = (2^N) - 1,
 129                 # that will generate unique values for all of the enums.
 130
 131                 mask = 0
 132                 for i in [1, 2, 3, 4, 5, 6, 7, 8]:
 133                         mask = (1 << i) - 1
 134
 135                         fail = 0;
 136                         for a in self.enums:
 137                                 for b in self.enums:
 138                                         if a != b:
 139                                                 if (a & mask) == (b & mask):
 140                                                         fail = 1;
 141
 142                         if not fail:
 143                                 break;
 144                         else:
 145                                 mask = 0
 146
 147                 if (mask != 0) and (mask < (2 * count)):
 148                         masked_enums = {}
 149                         masked_count = {}
 150
 151                         for i in range(0, mask + 1):
 152                                 masked_enums[i] = "0";
 153                                 masked_count[i] = 0;
 154
 155                         for c in self.count:
 156                                 for e in self.count[c]:
 157                                         i = e & mask
 158                                         masked_enums[i] = '0x%04x /* %s */' % (e, self.enums[e][0])
 159                                         masked_count[i] = c
 160
 161
 162                         print '    static const GLushort a[%u] = {' % (mask + 1)
 163                         for e in masked_enums:
 164                                 print '        %s, ' % (masked_enums[e])
 165                         print '    };'
 166
 167                         print '    static const GLubyte b[%u] = {' % (mask + 1)
 168                         for c in masked_count:
 169                                 print '        %u, ' % (masked_count[c])
 170                         print '    };'
 171
 172                         print '    const unsigned idx = (e & 0x%02xU);' % (mask)
 173                         print ''
 174                         print '    return (e == a[idx]) ? (GLint) b[idx] : 0;'
 175                         return 1;
 176                 else:
 177                         return 0;
 178
 179         def PrintUsingSwitch(self):
 180                 """Emit the body of the __gl*_size function using a
 181                 switch-statement."""
 182
 183                 print '    switch( e ) {'
 184
 185                 for c in self.count:
 186                         for e in self.count[c]:
 187                                 first = 1
 188
 189                                 # There may be multiple enums with the same
 190                                 # value.  This happens has extensions are
 191                                 # promoted from vendor-specific or EXT to
 192                                 # ARB and to the core.  Emit the first one as
 193                                 # a case label, and emit the others as
 194                                 # commented-out case labels.
 195
 196                                 for j in self.enums[e]:
 197                                         if first:
 198                                                 print '        case %s:' % (j)
 199                                                 first = 0
 200                                         else:
 201                                                 print '/*      case %s:*/' % (j)
 202
 203                         print '            return %u;' % (c)
 204
 205                 print '        default: return 0;'
 206                 print '    }'
 207
 208
 209         def Print(self, name):
 210                 print 'INTERNAL PURE FASTCALL GLint'
 211                 print '__gl%s_size( GLenum e )' % (name)
 212                 print '{'
 213
 214                 if not self.PrintUsingTable():
 215                         self.PrintUsingSwitch()
 216
 217                 print '}'
 218                 print ''
 219
 220
 221
 222 class glXEnum(gl_XML.glEnum):
 223         def __init__(self, context, name, attrs):
 224                 gl_XML.glEnum.__init__(self, context, name, attrs)
 225
 226
 227         def startElement(self, name, attrs):
 228                 if name == "size":
 229                         [n, c, mode] = self.process_attributes(attrs)
 230
 231                         if not self.context.glx_enum_functions.has_key( n ):
 232                                 f = self.context.createEnumFunction( n )
 233                                 f.set_mode( mode )
 234                                 self.context.glx_enum_functions[ f.name ] = f
 235
 236                         self.context.glx_enum_functions[ n ].append( c, self.value, self.name )
 237                 else:
 238                         gl_XML.glEnum.startElement(self, context, name, attrs)
 239                 return
 240
 241
 242 class glXParameter(gl_XML.glParameter):
 243         def __init__(self, context, name, attrs):
 244                 self.order = 1;
 245                 gl_XML.glParameter.__init__(self, context, name, attrs);
 246
 247
 248 class glXParameterIterator:
 249         """Class to iterate over a list of glXParameters.
 250
 251         Objects of this class are returned by the parameterIterator method of
 252         the glXFunction class.  They are used to iterate over the list of
 253         parameters to the function."""
 254
 255         def __init__(self, data, skip_output, max_order):
 256                 self.data = data
 257                 self.index = 0
 258                 self.order = 0
 259                 self.skip_output = skip_output
 260                 self.max_order = max_order
 261
 262         def __iter__(self):
 263                 return self
 264
 265         def next(self):
 266                 if len( self.data ) == 0:
 267                         raise StopIteration
 268
 269                 while 1:
 270                         if self.index == len( self.data ):
 271                                 if self.order == self.max_order:
 272                                         raise StopIteration
 273                                 else:
 274                                         self.order += 1
 275                                         self.index = 0
 276
 277                         i = self.index
 278                         self.index += 1
 279
 280                         if self.data[i].order == self.order and not (self.data[i].is_output and self.skip_output):
 281                                 return self.data[i]
 282
 283
 284 class glXFunction(gl_XML.glFunction):
 285         glx_rop = 0
 286         glx_sop = 0
 287         glx_vendorpriv = 0
 288
 289         # If this is set to true, it means that GLdouble parameters should be
 290         # written to the GLX protocol packet in the order they appear in the
 291         # prototype.  This is different from the "classic" ordering.  In the
 292         # classic ordering GLdoubles are written to the protocol packet first,
 293         # followed by non-doubles.  NV_vertex_program was the first extension
 294         # to break with this tradition.
 295
 296         glx_doubles_in_order = 0
 297
 298         vectorequiv = None
 299         can_be_large = 0
 300
 301         def __init__(self, context, name, attrs):
 302                 self.vectorequiv = attrs.get('vectorequiv', None)
 303                 self.count_parameters = None
 304                 self.counter = None
 305                 self.output = None
 306                 self.can_be_large = 0
 307                 self.reply_always_array = 0
 308
 309                 self.server_handcode = 0
 310                 self.client_handcode = 0
 311                 self.ignore = 0
 312
 313                 gl_XML.glFunction.__init__(self, context, name, attrs)
 314                 return
 315
 316
 317         def parameterIterator(self, skip_output, max_order):
 318                 return glXParameterIterator(self.fn_parameters, skip_output, max_order)
 319
 320
 321         def startElement(self, name, attrs):
 322                 """Process elements within a function that are specific to GLX."""
 323
 324                 if name == "glx":
 325                         self.glx_rop = int(attrs.get('rop', "0"))
 326                         self.glx_sop = int(attrs.get('sop', "0"))
 327                         self.glx_vendorpriv = int(attrs.get('vendorpriv', "0"))
 328
 329                         # The 'handcode' attribute can be one of 'true',
 330                         # 'false', 'client', or 'server'.
 331
 332                         handcode = attrs.get('handcode', "false")
 333                         if handcode == "false":
 334                                 self.server_handcode = 0
 335                                 self.client_handcode = 0
 336                         elif handcode == "true":
 337                                 self.server_handcode = 1
 338                                 self.client_handcode = 1
 339                         elif handcode == "client":
 340                                 self.server_handcode = 0
 341                                 self.client_handcode = 1
 342                         elif handcode == "server":
 343                                 self.server_handcode = 1
 344                                 self.client_handcode = 0
 345                         else:
 346                                 raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
 347
 348
 349                         if attrs.get('ignore', "false") == "true":
 350                                 self.ignore = 1
 351                         else:
 352                                 self.ignore = 0
 353
 354                         if attrs.get('large', "false") == "true":
 355                                 self.can_be_large = 1
 356                         else:
 357                                 self.can_be_large = 0
 358
 359                         if attrs.get('doubles_in_order', "false") == "true":
 360                                 self.glx_doubles_in_order = 1
 361                         else:
 362                                 self.glx_doubles_in_order = 0
 363
 364                         if attrs.get('always_array', "false") == "true":
 365                                 self.reply_always_array = 1
 366                         else:
 367                                 self.reply_always_array = 0
 368
 369                 else:
 370                         gl_XML.glFunction.startElement(self, name, attrs)
 371
 372
 373         def endElement(self, name):
 374                 if name == "function":
 375                         # Mark any function that does not have GLX protocol
 376                         # defined as "ignore".  This prevents bad things from
 377                         # happening when people add new functions to the GL
 378                         # API XML without adding any GLX section.
 379                         #
 380                         # This will also mark functions that don't have a
 381                         # dispatch offset at ignored.
 382
 383                         if (self.fn_offset == -1 and not self.fn_alias) or not (self.client_handcode or self.server_handcode or self.glx_rop or self.glx_sop or self.glx_vendorpriv or self.vectorequiv or self.fn_alias):
 384                                 #if not self.ignore:
 385                                 #       if self.fn_offset == -1:
 386                                 #               print '/* %s ignored becuase no offset assigned. */' % (self.name)
 387                                 #       else:
 388                                 #               print '/* %s ignored becuase no GLX opcode assigned. */' % (self.name)
 389
 390                                 self.ignore = 1
 391
 392                 return gl_XML.glFunction.endElement(self, name)
 393
 394
 395         def append(self, tag_name, p):
 396                 gl_XML.glFunction.append(self, tag_name, p)
 397
 398                 if p.is_variable_length_array():
 399                         p.order = 2;
 400                 elif not self.glx_doubles_in_order and p.p_type.size == 8:
 401                         p.order = 0;
 402
 403                 if p.p_count_parameters != None:
 404                         self.count_parameters = p.p_count_parameters
 405
 406                 if p.is_counter:
 407                         self.counter = p.name
 408
 409                 if p.is_output:
 410                         self.output = p
 411
 412                 return
 413
 414
 415         def variable_length_parameter(self):
 416                 for param in self.fn_parameters:
 417                         if param.is_variable_length_array():
 418                                 return param
 419
 420                 return None
 421
 422
 423         def output_parameter(self):
 424                 for param in self.fn_parameters:
 425                         if param.is_output:
 426                                 return param
 427
 428                 return None
 429
 430
 431         def offset_of_first_parameter(self):
 432                 """Get the offset of the first parameter in the command.
 433
 434                 Gets the offset of the first function parameter in the GLX
 435                 command packet.  This byte offset is measured from the end
 436                 of the Render / RenderLarge header.  The offset for all non-
 437                 pixel commends is zero.  The offset for pixel commands depends
 438                 on the number of dimensions of the pixel data."""
 439
 440                 if self.image:
 441                         [dim, junk, junk, junk, junk] = self.dimensions()
 442
 443                         # The base size is the size of the pixel pack info
 444                         # header used by images with the specified number
 445                         # of dimensions.
 446
 447                         if dim <=  2:
 448                                 return 20
 449                         elif dim <= 4:
 450                                 return 36
 451                         else:
 452                                 raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
 453                 else:
 454                         return 0
 455
 456
 457         def command_fixed_length(self):
 458                 """Return the length, in bytes as an integer, of the
 459                 fixed-size portion of the command."""
 460
 461                 size = self.offset_of_first_parameter()
 462
 463                 for p in gl_XML.glFunction.parameterIterator(self):
 464                         if not p.is_output:
 465                                 size += p.size()
 466                                 if self.pad_after(p):
 467                                         size += 4
 468
 469                 if self.image and self.image.img_null_flag:
 470                         size += 4
 471
 472                 return size
 473
 474
 475         def command_variable_length(self):
 476                 """Return the length, as a string, of the variable-sized
 477                 portion of the command."""
 478
 479                 size_string = ""
 480                 for p in gl_XML.glFunction.parameterIterator(self):
 481                         if (not p.is_output) and (p.size() == 0):
 482                                 size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string())
 483
 484                 return size_string
 485
 486
 487         def command_length(self):
 488                 size = self.command_fixed_length()
 489
 490                 if self.glx_rop != 0:
 491                         size += 4
 492
 493                 size = ((size + 3) & ~3)
 494                 return "%u%s" % (size, self.command_variable_length())
 495
 496
 497         def opcode_real_value(self):
 498                 """Get the true numeric value of the GLX opcode
 499
 500                 Behaves similarly to opcode_value, except for
 501                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 502                 In these cases the value for the GLX opcode field (i.e.,
 503                 16 for X_GLXVendorPrivate or 17 for
 504                 X_GLXVendorPrivateWithReply) is returned.  For other 'single'
 505                 commands, the opcode for the command (e.g., 101 for
 506                 X_GLsop_NewList) is returned."""
 507
 508                 if self.glx_vendorpriv != 0:
 509                         if self.needs_reply():
 510                                 return 17
 511                         else:
 512                                 return 16
 513                 else:
 514                         return self.opcode_value()
 515
 516         def opcode_value(self):
 517                 """Get the unique protocol opcode for the glXFunction"""
 518
 519                 if self.glx_rop != 0:
 520                         return self.glx_rop
 521                 elif self.glx_sop != 0:
 522                         return self.glx_sop
 523                 elif self.glx_vendorpriv != 0:
 524                         return self.glx_vendorpriv
 525                 else:
 526                         return -1
 527
 528         def opcode_rop_basename(self):
 529                 """Return either the name to be used for GLX protocol enum.
 530
 531                 Returns either the name of the function or the name of the
 532                 name of the equivalent vector (e.g., glVertex3fv for
 533                 glVertex3f) function."""
 534
 535                 if self.vectorequiv == None:
 536                         return self.name
 537                 else:
 538                         return self.vectorequiv
 539
 540         def opcode_name(self):
 541                 """Get the unique protocol enum name for the glXFunction"""
 542
 543                 if self.glx_rop != 0:
 544                         return "X_GLrop_%s" % (self.opcode_rop_basename())
 545                 elif self.glx_sop != 0:
 546                         return "X_GLsop_%s" % (self.name)
 547                 elif self.glx_vendorpriv != 0:
 548                         return "X_GLvop_%s" % (self.name)
 549                 else:
 550                         return "ERROR"
 551
 552         def opcode_real_name(self):
 553                 """Get the true protocol enum name for the GLX opcode
 554
 555                 Behaves similarly to opcode_name, except for
 556                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 557                 In these cases the string 'X_GLXVendorPrivate' or
 558                 'X_GLXVendorPrivateWithReply' is returned.  For other
 559                 single or render commands 'X_GLsop' or 'X_GLrop' plus the
 560                 name of the function returned."""
 561
 562                 if self.glx_vendorpriv != 0:
 563                         if self.needs_reply():
 564                                 return "X_GLXVendorPrivateWithReply"
 565                         else:
 566                                 return "X_GLXVendorPrivate"
 567                 else:
 568                         return self.opcode_name()
 569
 570
 571         def return_string(self):
 572                 if self.fn_return_type != 'void':
 573                         return "return retval;"
 574                 else:
 575                         return "return;"
 576
 577
 578         def needs_reply(self):
 579                 return self.fn_return_type != 'void' or self.output != None
 580
 581
 582         def dimensions(self):
 583                 """Determine the dimensions of an image.
 584
 585                 Returns a tuple representing the number of dimensions and the
 586                 string name of each of the dimensions of an image,  If the
 587                 function is not a pixel function, the number of dimensions
 588                 will be zero."""
 589
 590                 if not self.image:
 591                         return [0, "0", "0", "0", "0"]
 592                 else:
 593                         dim = 1
 594                         w = self.image.width
 595
 596                         if self.image.height:
 597                                 dim = 2
 598                                 h = self.image.height
 599                         else:
 600                                 h = "1"
 601
 602                         if self.image.depth:
 603                                 dim = 3
 604                                 d = self.image.depth
 605                         else:
 606                                 d = "1"
 607
 608                         if self.image.extent:
 609                                 dim = 4
 610                                 e = self.image.extent
 611                         else:
 612                                 e = "1"
 613
 614                         return [dim, w, h, d, e]
 615
 616
 617         def pad_after(self, p):
 618                 """Returns the name of the field inserted after the
 619                 specified field to pad out the command header."""
 620
 621                 if self.image and self.image.img_pad_dimensions:
 622                         if not self.image.height:
 623                                 if p.name == self.image.width:
 624                                         return "height"
 625                                 elif p.name == self.image.img_xoff:
 626                                         return "yoffset"
 627                         elif not self.image.extent:
 628                                 if p.name == self.image.depth:
 629                                         # Should this be "size4d"?
 630                                         return "extent"
 631                                 elif p.name == self.image.img_zoff:
 632                                         return "woffset"
 633                 return None
 634
 635
 636 class GlxProto(gl_XML.FilterGLAPISpecBase):
 637         name = "glX_proto_send.py (from Mesa)"
 638
 639         def __init__(self):
 640                 gl_XML.FilterGLAPISpecBase.__init__(self)
 641                 self.factory = glXItemFactory()
 642                 self.glx_enum_functions = {}
 643
 644
 645         def endElement(self, name):
 646                 if name == 'OpenGLAPI':
 647                         # Once all the parsing is done, we have to go back and
 648                         # fix-up some cross references between different
 649                         # functions.
 650
 651                         for k in self.functions:
 652                                 f = self.functions[k]
 653                                 if f.vectorequiv != None:
 654                                         equiv = self.find_function(f.vectorequiv)
 655                                         if equiv != None:
 656                                                 f.glx_doubles_in_order = equiv.glx_doubles_in_order
 657                                                 f.glx_rop = equiv.glx_rop
 658                                         else:
 659                                                 raise RuntimeError("Could not find the vector equiv. function %s for %s!" % (f.name, f.vectorequiv))
 660                 else:
 661                         gl_XML.FilterGLAPISpecBase.endElement(self, name)
 662                 return
 663
 664
 665         def createEnumFunction(self, n):
 666                 return glXEnumFunction(n, self)