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, string
  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.counter = None
 304                 self.output = None
 305                 self.can_be_large = 0
 306                 self.reply_always_array = 0
 307                 self.dimensions_in_reply = 0
 308                 self.img_reset = None
 309
 310                 self.server_handcode = 0
 311                 self.client_handcode = 0
 312                 self.ignore = 0
 313
 314                 gl_XML.glFunction.__init__(self, context, name, attrs)
 315                 return
 316
 317
 318         def parameterIterator(self, skip_output, max_order):
 319                 return glXParameterIterator(self.fn_parameters, skip_output, max_order)
 320
 321
 322         def startElement(self, name, attrs):
 323                 """Process elements within a function that are specific to GLX."""
 324
 325                 if name == "glx":
 326                         self.glx_rop = int(attrs.get('rop', "0"))
 327                         self.glx_sop = int(attrs.get('sop', "0"))
 328                         self.glx_vendorpriv = int(attrs.get('vendorpriv', "0"))
 329                         self.img_reset = attrs.get('img_reset', None)
 330
 331                         # The 'handcode' attribute can be one of 'true',
 332                         # 'false', 'client', or 'server'.
 333
 334                         handcode = attrs.get('handcode', "false")
 335                         if handcode == "false":
 336                                 self.server_handcode = 0
 337                                 self.client_handcode = 0
 338                         elif handcode == "true":
 339                                 self.server_handcode = 1
 340                                 self.client_handcode = 1
 341                         elif handcode == "client":
 342                                 self.server_handcode = 0
 343                                 self.client_handcode = 1
 344                         elif handcode == "server":
 345                                 self.server_handcode = 1
 346                                 self.client_handcode = 0
 347                         else:
 348                                 raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
 349
 350
 351                         if attrs.get('ignore', "false") == "true":
 352                                 self.ignore = 1
 353                         else:
 354                                 self.ignore = 0
 355
 356                         if attrs.get('large', "false") == "true":
 357                                 self.can_be_large = 1
 358                         else:
 359                                 self.can_be_large = 0
 360
 361                         if attrs.get('doubles_in_order', "false") == "true":
 362                                 self.glx_doubles_in_order = 1
 363                         else:
 364                                 self.glx_doubles_in_order = 0
 365
 366                         if attrs.get('always_array', "false") == "true":
 367                                 self.reply_always_array = 1
 368                         else:
 369                                 self.reply_always_array = 0
 370
 371                         if attrs.get('dimensions_in_reply', "false") == "true":
 372                                 self.dimensions_in_reply = 1
 373                         else:
 374                                 self.dimensions_in_reply = 0
 375                 else:
 376                         gl_XML.glFunction.startElement(self, name, attrs)
 377
 378
 379         def endElement(self, name):
 380                 if name == "function":
 381                         # Mark any function that does not have GLX protocol
 382                         # defined as "ignore".  This prevents bad things from
 383                         # happening when people add new functions to the GL
 384                         # API XML without adding any GLX section.
 385                         #
 386                         # This will also mark functions that don't have a
 387                         # dispatch offset at ignored.
 388
 389                         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):
 390                                 #if not self.ignore:
 391                                 #       if self.fn_offset == -1:
 392                                 #               print '/* %s ignored becuase no offset assigned. */' % (self.name)
 393                                 #       else:
 394                                 #               print '/* %s ignored becuase no GLX opcode assigned. */' % (self.name)
 395
 396                                 self.ignore = 1
 397
 398                 return gl_XML.glFunction.endElement(self, name)
 399
 400
 401         def append(self, tag_name, p):
 402                 gl_XML.glFunction.append(self, tag_name, p)
 403
 404                 if p.is_variable_length_array():
 405                         p.order = 2;
 406                 elif not self.glx_doubles_in_order and p.p_type.size == 8:
 407                         p.order = 0;
 408
 409                 if p.is_counter:
 410                         self.counter = p.name
 411
 412                 if p.is_output:
 413                         self.output = p
 414
 415                 return
 416
 417
 418         def variable_length_parameter(self):
 419                 for param in self.fn_parameters:
 420                         if param.is_variable_length_array():
 421                                 return param
 422
 423                 return None
 424
 425
 426         def output_parameter(self):
 427                 for param in self.fn_parameters:
 428                         if param.is_output:
 429                                 return param
 430
 431                 return None
 432
 433
 434         def offset_of_first_parameter(self):
 435                 """Get the offset of the first parameter in the command.
 436
 437                 Gets the offset of the first function parameter in the GLX
 438                 command packet.  This byte offset is measured from the end
 439                 of the Render / RenderLarge header.  The offset for all non-
 440                 pixel commends is zero.  The offset for pixel commands depends
 441                 on the number of dimensions of the pixel data."""
 442
 443                 if self.image and not self.image.is_output:
 444                         [dim, junk, junk, junk, junk] = self.dimensions()
 445
 446                         # The base size is the size of the pixel pack info
 447                         # header used by images with the specified number
 448                         # of dimensions.
 449
 450                         if dim <=  2:
 451                                 return 20
 452                         elif dim <= 4:
 453                                 return 36
 454                         else:
 455                                 raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
 456                 else:
 457                         return 0
 458
 459
 460         def command_fixed_length(self):
 461                 """Return the length, in bytes as an integer, of the
 462                 fixed-size portion of the command."""
 463
 464                 size = self.offset_of_first_parameter()
 465
 466                 for p in gl_XML.glFunction.parameterIterator(self):
 467                         if not p.is_output and p.name != self.img_reset:
 468                                 size += p.size()
 469                                 if self.pad_after(p):
 470                                         size += 4
 471
 472                 if self.image and (self.image.img_null_flag or self.image.is_output):
 473                         size += 4
 474
 475                 return size
 476
 477
 478         def command_variable_length(self):
 479                 """Return the length, as a string, of the variable-sized
 480                 portion of the command."""
 481
 482                 size_string = ""
 483                 for p in gl_XML.glFunction.parameterIterator(self):
 484                         if (not p.is_output) and (p.size() == 0):
 485                                 size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string())
 486
 487                 return size_string
 488
 489
 490         def command_length(self):
 491                 size = self.command_fixed_length()
 492
 493                 if self.glx_rop != 0:
 494                         size += 4
 495
 496                 size = ((size + 3) & ~3)
 497                 return "%u%s" % (size, self.command_variable_length())
 498
 499
 500         def opcode_real_value(self):
 501                 """Get the true numeric value of the GLX opcode
 502
 503                 Behaves similarly to opcode_value, except for
 504                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 505                 In these cases the value for the GLX opcode field (i.e.,
 506                 16 for X_GLXVendorPrivate or 17 for
 507                 X_GLXVendorPrivateWithReply) is returned.  For other 'single'
 508                 commands, the opcode for the command (e.g., 101 for
 509                 X_GLsop_NewList) is returned."""
 510
 511                 if self.glx_vendorpriv != 0:
 512                         if self.needs_reply():
 513                                 return 17
 514                         else:
 515                                 return 16
 516                 else:
 517                         return self.opcode_value()
 518
 519         def opcode_value(self):
 520                 """Get the unique protocol opcode for the glXFunction"""
 521
 522                 if self.glx_rop != 0:
 523                         return self.glx_rop
 524                 elif self.glx_sop != 0:
 525                         return self.glx_sop
 526                 elif self.glx_vendorpriv != 0:
 527                         return self.glx_vendorpriv
 528                 else:
 529                         return -1
 530
 531         def opcode_rop_basename(self):
 532                 """Return either the name to be used for GLX protocol enum.
 533
 534                 Returns either the name of the function or the name of the
 535                 name of the equivalent vector (e.g., glVertex3fv for
 536                 glVertex3f) function."""
 537
 538                 if self.vectorequiv == None:
 539                         return self.name
 540                 else:
 541                         return self.vectorequiv
 542
 543         def opcode_name(self):
 544                 """Get the unique protocol enum name for the glXFunction"""
 545
 546                 if self.glx_rop != 0:
 547                         return "X_GLrop_%s" % (self.opcode_rop_basename())
 548                 elif self.glx_sop != 0:
 549                         return "X_GLsop_%s" % (self.name)
 550                 elif self.glx_vendorpriv != 0:
 551                         return "X_GLvop_%s" % (self.name)
 552                 else:
 553                         raise RuntimeError('Function "%s" has no opcode.' % (self.name))
 554
 555
 556         def opcode_real_name(self):
 557                 """Get the true protocol enum name for the GLX opcode
 558
 559                 Behaves similarly to opcode_name, except for
 560                 X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
 561                 In these cases the string 'X_GLXVendorPrivate' or
 562                 'X_GLXVendorPrivateWithReply' is returned.  For other
 563                 single or render commands 'X_GLsop' or 'X_GLrop' plus the
 564                 name of the function returned."""
 565
 566                 if self.glx_vendorpriv != 0:
 567                         if self.needs_reply():
 568                                 return "X_GLXVendorPrivateWithReply"
 569                         else:
 570                                 return "X_GLXVendorPrivate"
 571                 else:
 572                         return self.opcode_name()
 573
 574
 575         def return_string(self):
 576                 if self.fn_return_type != 'void':
 577                         return "return retval;"
 578                 else:
 579                         return "return;"
 580
 581
 582         def needs_reply(self):
 583                 return self.fn_return_type != 'void' or self.output != None
 584
 585
 586         def dimensions(self):
 587                 """Determine the dimensions of an image.
 588
 589                 Returns a tuple representing the number of dimensions and the
 590                 string name of each of the dimensions of an image,  If the
 591                 function is not a pixel function, the number of dimensions
 592                 will be zero."""
 593
 594                 if not self.image:
 595                         return [0, "0", "0", "0", "0"]
 596                 else:
 597                         dim = 1
 598                         w = self.image.width
 599
 600                         if self.image.height:
 601                                 dim = 2
 602                                 h = self.image.height
 603                         else:
 604                                 h = "1"
 605
 606                         if self.image.depth:
 607                                 dim = 3
 608                                 d = self.image.depth
 609                         else:
 610                                 d = "1"
 611
 612                         if self.image.extent:
 613                                 dim = 4
 614                                 e = self.image.extent
 615                         else:
 616                                 e = "1"
 617
 618                         return [dim, w, h, d, e]
 619
 620
 621         def pad_after(self, p):
 622                 """Returns the name of the field inserted after the
 623                 specified field to pad out the command header."""
 624
 625                 if self.image and self.image.img_pad_dimensions:
 626                         if not self.image.height:
 627                                 if p.name == self.image.width:
 628                                         return "height"
 629                                 elif p.name == self.image.img_xoff:
 630                                         return "yoffset"
 631                         elif not self.image.extent:
 632                                 if p.name == self.image.depth:
 633                                         # Should this be "size4d"?
 634                                         return "extent"
 635                                 elif p.name == self.image.img_zoff:
 636                                         return "woffset"
 637                 return None
 638
 639
 640 class glXFunctionIterator(gl_XML.glFunctionIterator):
 641         """Class to iterate over a list of glXFunctions"""
 642
 643         def __init__(self, context):
 644                 self.context = context
 645                 self.keys = context.functions.keys()
 646                 self.keys.sort()
 647
 648                 for self.index in range(0, len(self.keys)):
 649                         if self.keys[ self.index ] >= 0: break
 650
 651                 return
 652
 653
 654         def next(self):
 655                 if self.index == len(self.keys):
 656                         raise StopIteration
 657
 658                 f = self.context.functions[ self.keys[ self.index ] ]
 659                 self.index += 1
 660
 661                 if f.ignore:
 662                         return self.next()
 663                 else:
 664                         return f
 665
 666
 667 class GlxProto(gl_XML.FilterGLAPISpecBase):
 668         name = "glX_proto_send.py (from Mesa)"
 669
 670         def __init__(self):
 671                 gl_XML.FilterGLAPISpecBase.__init__(self)
 672                 self.factory = glXItemFactory()
 673                 self.glx_enum_functions = {}
 674
 675
 676         def endElement(self, name):
 677                 if name == 'OpenGLAPI':
 678                         # Once all the parsing is done, we have to go back and
 679                         # fix-up some cross references between different
 680                         # functions.
 681
 682                         for k in self.functions:
 683                                 f = self.functions[k]
 684                                 if f.vectorequiv != None:
 685                                         equiv = self.find_function(f.vectorequiv)
 686                                         if equiv != None:
 687                                                 f.glx_doubles_in_order = equiv.glx_doubles_in_order
 688                                                 f.glx_rop = equiv.glx_rop
 689                                         else:
 690                                                 raise RuntimeError("Could not find the vector equiv. function %s for %s!" % (f.name, f.vectorequiv))
 691                 else:
 692                         gl_XML.FilterGLAPISpecBase.endElement(self, name)
 693                 return
 694
 695
 696         def createEnumFunction(self, n):
 697                 return glXEnumFunction(n, self)
 698
 699
 700         def functionIterator(self):
 701                 return glXFunctionIterator(self)
 702
 703
 704         def size_call(self, func):
 705                 """Create C code to calculate 'compsize'.
 706
 707                 Creates code to calculate 'compsize'.  If the function does
 708                 not need 'compsize' to be calculated, None will be
 709                 returned."""
 710
 711                 if not func.image and not func.count_parameter_list:
 712                         return None
 713
 714                 if not func.image:
 715                         parameters = string.join( func.count_parameter_list, "," )
 716                         compsize = "__gl%s_size(%s)" % (func.name, parameters)
 717                 else:
 718                         [dim, w, h, d, junk] = func.dimensions()
 719
 720                         compsize = '__glImageSize(%s, %s, %s, %s, %s, %s)' % (w, h, d, func.image.img_format, func.image.img_type, func.image.img_target)
 721                         if not func.image.img_send_null:
 722                                 compsize = '(%s != NULL) ? %s : 0' % (func.image.name, compsize)
 723
 724                 return compsize