glapi: Reformat python code generation scripts to use 4-space indentation.

This brings us into accordance with the official Python style guide
(http://www.python.org/dev/peps/pep-0008/#indentation).

To preserve the indentation of the c code that is generated by these
scripts, I've avoided re-indenting triple-quoted strings (unless those
strings appear to be docstrings).

Acked-by: Kenneth Graunke <[email protected]>
Reviewed-by: Ian Romanick <[email protected]>

1 files changed, 468 insertions, 468 deletions

diff --git a/src/mapi/glapi/gen/glX_XML.py b/src/mapi/glapi/gen/glX_XML.py
index 4c2e0f95bf4..975321a76ab 100644
--- a/src/mapi/glapi/gen/glX_XML.py
+++ b/src/mapi/glapi/gen/glX_XML.py
@@ -31,540 +31,540 @@ import sys, getopt, string
 
 
 class glx_item_factory(gl_XML.gl_item_factory):
-	"""Factory to create GLX protocol oriented objects derived from gl_item."""
-    
-	def create_item(self, name, element, context):
-		if name == "function":
-			return glx_function(element, context)
-		elif name == "enum":
-			return glx_enum(element, context)
-		elif name == "api":
-			return glx_api(self)
-		else:
-			return gl_XML.gl_item_factory.create_item(self, name, element, context)
+    """Factory to create GLX protocol oriented objects derived from gl_item."""
+
+    def create_item(self, name, element, context):
+        if name == "function":
+            return glx_function(element, context)
+        elif name == "enum":
+            return glx_enum(element, context)
+        elif name == "api":
+            return glx_api(self)
+        else:
+            return gl_XML.gl_item_factory.create_item(self, name, element, context)
 
 
 class glx_enum(gl_XML.gl_enum):
-	def __init__(self, element, context):
-		gl_XML.gl_enum.__init__(self, element, context)
-		
-		self.functions = {}
+    def __init__(self, element, context):
+        gl_XML.gl_enum.__init__(self, element, context)
+
+        self.functions = {}
+
+        child = element.children
+        while child:
+            if child.type == "element" and child.name == "size":
+                n = child.nsProp( "name", None )
+                c = child.nsProp( "count", None )
+                m = child.nsProp( "mode", None )
 
-		child = element.children
-		while child:
-			if child.type == "element" and child.name == "size":
-				n = child.nsProp( "name", None )
-				c = child.nsProp( "count", None )
-				m = child.nsProp( "mode", None )
-				
-				if not c:
-					c = self.default_count
-				else:
-					c = int(c)
+                if not c:
+                    c = self.default_count
+                else:
+                    c = int(c)
 
-				if m == "get":
-					mode = 0
-				else:
-					mode = 1
+                if m == "get":
+                    mode = 0
+                else:
+                    mode = 1
 
-				if not self.functions.has_key(n):
-					self.functions[ n ] = [c, mode]
+                if not self.functions.has_key(n):
+                    self.functions[ n ] = [c, mode]
 
-			child = child.next
+            child = child.next
 
-		return
+        return
 
 
 class glx_function(gl_XML.gl_function):
-	def __init__(self, element, context):
-		self.glx_rop = 0
-		self.glx_sop = 0
-		self.glx_vendorpriv = 0
-
-		self.glx_vendorpriv_names = []
-
-		# If this is set to true, it means that GLdouble parameters should be
-		# written to the GLX protocol packet in the order they appear in the
-		# prototype.  This is different from the "classic" ordering.  In the
-		# classic ordering GLdoubles are written to the protocol packet first,
-		# followed by non-doubles.  NV_vertex_program was the first extension
-		# to break with this tradition.
-
-		self.glx_doubles_in_order = 0
+    def __init__(self, element, context):
+        self.glx_rop = 0
+        self.glx_sop = 0
+        self.glx_vendorpriv = 0
+
+        self.glx_vendorpriv_names = []
+
+        # If this is set to true, it means that GLdouble parameters should be
+        # written to the GLX protocol packet in the order they appear in the
+        # prototype.  This is different from the "classic" ordering.  In the
+        # classic ordering GLdoubles are written to the protocol packet first,
+        # followed by non-doubles.  NV_vertex_program was the first extension
+        # to break with this tradition.
+
+        self.glx_doubles_in_order = 0
+
+        self.vectorequiv = None
+        self.output = None
+        self.can_be_large = 0
+        self.reply_always_array = 0
+        self.dimensions_in_reply = 0
+        self.img_reset = None
+
+        self.server_handcode = 0
+        self.client_handcode = 0
+        self.ignore = 0
+
+        self.count_parameter_list = []
+        self.counter_list = []
+        self.parameters_by_name = {}
+        self.offsets_calculated = 0
+
+        gl_XML.gl_function.__init__(self, element, context)
+        return
+
+
+    def process_element(self, element):
+        gl_XML.gl_function.process_element(self, element)
+
+        # If the function already has a vector equivalent set, don't
+        # set it again.  This can happen if an alias to a function
+        # appears after the function that it aliases.
+
+        if not self.vectorequiv:
+            self.vectorequiv = element.nsProp("vectorequiv", None)
+
+
+        name = element.nsProp("name", None)
+        if name == self.name:
+            for param in self.parameters:
+                self.parameters_by_name[ param.name ] = param
+
+                if len(param.count_parameter_list):
+                    self.count_parameter_list.extend( param.count_parameter_list )
+
+                if param.counter and param.counter not in self.counter_list:
+                    self.counter_list.append(param.counter)
+
+
+        child = element.children
+        while child:
+            if child.type == "element" and child.name == "glx":
+                rop = child.nsProp( 'rop', None )
+                sop = child.nsProp( 'sop', None )
+                vop = child.nsProp( 'vendorpriv', None )
+
+                if rop:
+                    self.glx_rop = int(rop)
+
+                if sop:
+                    self.glx_sop = int(sop)
+
+                if vop:
+                    self.glx_vendorpriv = int(vop)
+                    self.glx_vendorpriv_names.append(name)
+
+                self.img_reset = child.nsProp( 'img_reset', None )
+
+                # The 'handcode' attribute can be one of 'true',
+                # 'false', 'client', or 'server'.
+
+                handcode = child.nsProp( 'handcode', None )
+                if handcode == "false":
+                    self.server_handcode = 0
+                    self.client_handcode = 0
+                elif handcode == "true":
+                    self.server_handcode = 1
+                    self.client_handcode = 1
+                elif handcode == "client":
+                    self.server_handcode = 0
+                    self.client_handcode = 1
+                elif handcode == "server":
+                    self.server_handcode = 1
+                    self.client_handcode = 0
+                else:
+                    raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
+
+                self.ignore               = gl_XML.is_attr_true( child, 'ignore' )
+                self.can_be_large         = gl_XML.is_attr_true( child, 'large' )
+                self.glx_doubles_in_order = gl_XML.is_attr_true( child, 'doubles_in_order' )
+                self.reply_always_array   = gl_XML.is_attr_true( child, 'always_array' )
+                self.dimensions_in_reply  = gl_XML.is_attr_true( child, 'dimensions_in_reply' )
+
+            child = child.next
+
+
+        # Do some validation of the GLX protocol information.  As
+        # new tests are discovered, they should be added here.
+
+        for param in self.parameters:
+            if param.is_output and self.glx_rop != 0:
+                raise RuntimeError("Render / RenderLarge commands cannot have outputs (%s)." % (self.name))
+
+        return
+
+
+    def has_variable_size_request(self):
+        """Determine if the GLX request packet is variable sized.
+
+        The GLX request packet is variable sized in several common
+        situations.
+
+        1. The function has a non-output parameter that is counted
+           by another parameter (e.g., the 'textures' parameter of
+           glDeleteTextures).
+
+        2. The function has a non-output parameter whose count is
+           determined by another parameter that is an enum (e.g., the
+           'params' parameter of glLightfv).
+
+        3. The function has a non-output parameter that is an
+           image.
+
+        4. The function must be hand-coded on the server.
+        """
+
+        if self.glx_rop == 0:
+            return 0
+
+        if self.server_handcode or self.images:
+            return 1
+
+        for param in self.parameters:
+            if not param.is_output:
+                if param.counter or len(param.count_parameter_list):
+                    return 1
+
+        return 0
+
+
+    def variable_length_parameter(self):
+        for param in self.parameters:
+            if not param.is_output:
+                if param.counter or len(param.count_parameter_list):
+                    return param
+
+        return None
+
+
+    def calculate_offsets(self):
+        if not self.offsets_calculated:
+            # Calculate the offset of the first function parameter
+            # in the GLX command packet.  This byte offset is
+            # measured from the end of the Render / RenderLarge
+            # header.  The offset for all non-pixel commends is
+            # zero.  The offset for pixel commands depends on the
+            # number of dimensions of the pixel data.
+
+            if len(self.images) and not self.images[0].is_output:
+                [dim, junk, junk, junk, junk] = self.images[0].get_dimensions()
+
+                # The base size is the size of the pixel pack info
+                # header used by images with the specified number
+                # of dimensions.
+
+                if dim <=  2:
+                    offset = 20
+                elif dim <= 4:
+                    offset = 36
+                else:
+                    raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
+            else:
+                offset = 0
+
+            for param in self.parameterIterateGlxSend():
+                if param.img_null_flag:
+                    offset += 4
+
+                if param.name != self.img_reset:
+                    param.offset = offset
+                    if not param.is_variable_length() and not param.is_client_only:
+                        offset += param.size()
+
+                if self.pad_after( param ):
+                    offset += 4
+
+
+            self.offsets_calculated = 1
+        return
+
+
+    def offset_of(self, param_name):
+        self.calculate_offsets()
+        return self.parameters_by_name[ param_name ].offset
+
+
+    def parameterIterateGlxSend(self, include_variable_parameters = 1):
+        """Create an iterator for parameters in GLX request order."""
+
+        # The parameter lists are usually quite short, so it's easier
+        # (i.e., less code) to just generate a new list with the
+        # required elements than it is to create a new iterator class.
+
+        temp = [ [],  [], [] ]
+        for param in self.parameters:
+            if param.is_output: continue
+
+            if param.is_variable_length():
+                temp[2].append( param )
+            elif not self.glx_doubles_in_order and param.is_64_bit():
+                temp[0].append( param )
+            else:
+                temp[1].append( param )
+
+        parameters = temp[0]
+        parameters.extend( temp[1] )
+        if include_variable_parameters:
+            parameters.extend( temp[2] )
+        return parameters.__iter__()
+
+
+    def parameterIterateCounters(self):
+        temp = []
+        for name in self.counter_list:
+            temp.append( self.parameters_by_name[ name ] )
+
+        return temp.__iter__()
+
+
+    def parameterIterateOutputs(self):
+        temp = []
+        for p in self.parameters:
+            if p.is_output:
+                temp.append( p )
+
+        return temp
+
+
+    def command_fixed_length(self):
+        """Return the length, in bytes as an integer, of the
+        fixed-size portion of the command."""
+
+        if len(self.parameters) == 0:
+            return 0
+
+        self.calculate_offsets()
+
+        size = 0
+        for param in self.parameterIterateGlxSend(0):
+            if param.name != self.img_reset and not param.is_client_only:
+                if size == 0:
+                    size = param.offset + param.size()
+                else:
+                    size += param.size()
+
+                if self.pad_after( param ):
+                    size += 4
+
+        for param in self.images:
+            if param.img_null_flag or param.is_output:
+                size += 4
+
+        return size
+
+
+    def command_variable_length(self):
+        """Return the length, as a string, of the variable-sized
+        portion of the command."""
+
+        size_string = ""
+        for p in self.parameterIterateGlxSend():
+            if (not p.is_output) and (p.is_variable_length() or p.is_image()):
+                # FIXME Replace the 1 in the size_string call
+                # FIXME w/0 to eliminate some un-needed parnes
+                # FIXME This would already be done, but it
+                # FIXME adds some extra diffs to the generated
+                # FIXME code.
+
+                size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string(1))
+
+        return size_string
+
+
+    def command_length(self):
+        size = self.command_fixed_length()
 
-		self.vectorequiv = None
-		self.output = None
-		self.can_be_large = 0
-		self.reply_always_array = 0
-		self.dimensions_in_reply = 0
-		self.img_reset = None
-
-		self.server_handcode = 0
-		self.client_handcode = 0
-		self.ignore = 0
-
-		self.count_parameter_list = []
-		self.counter_list = []
-		self.parameters_by_name = {}
-		self.offsets_calculated = 0
-
-		gl_XML.gl_function.__init__(self, element, context)
-		return
-
-
-	def process_element(self, element):
-		gl_XML.gl_function.process_element(self, element)
-
-		# If the function already has a vector equivalent set, don't
-		# set it again.  This can happen if an alias to a function
-		# appears after the function that it aliases.
-
-		if not self.vectorequiv:
-			self.vectorequiv = element.nsProp("vectorequiv", None)
-
-
-		name = element.nsProp("name", None)
-		if name == self.name:
-			for param in self.parameters:
-				self.parameters_by_name[ param.name ] = param
-				
-				if len(param.count_parameter_list):
-					self.count_parameter_list.extend( param.count_parameter_list )
-				
-				if param.counter and param.counter not in self.counter_list:
-					self.counter_list.append(param.counter)
+        if self.glx_rop != 0:
+            size += 4
 
+        size = ((size + 3) & ~3)
+        return "%u%s" % (size, self.command_variable_length())
 
-		child = element.children
-		while child:
-			if child.type == "element" and child.name == "glx":
-				rop = child.nsProp( 'rop', None )
-				sop = child.nsProp( 'sop', None )
-				vop = child.nsProp( 'vendorpriv', None )
-
-				if rop:
-					self.glx_rop = int(rop)
-
-				if sop:
-					self.glx_sop = int(sop)
-
-				if vop:
-					self.glx_vendorpriv = int(vop)
-					self.glx_vendorpriv_names.append(name)
-
-				self.img_reset = child.nsProp( 'img_reset', None )
-
-				# The 'handcode' attribute can be one of 'true',
-				# 'false', 'client', or 'server'.
-
-				handcode = child.nsProp( 'handcode', None )
-				if handcode == "false":
-					self.server_handcode = 0
-					self.client_handcode = 0
-				elif handcode == "true":
-					self.server_handcode = 1
-					self.client_handcode = 1
-				elif handcode == "client":
-					self.server_handcode = 0
-					self.client_handcode = 1
-				elif handcode == "server":
-					self.server_handcode = 1
-					self.client_handcode = 0
-				else:
-					raise RuntimeError('Invalid handcode mode "%s" in function "%s".' % (handcode, self.name))
-
-				self.ignore               = gl_XML.is_attr_true( child, 'ignore' )
-				self.can_be_large         = gl_XML.is_attr_true( child, 'large' )
-				self.glx_doubles_in_order = gl_XML.is_attr_true( child, 'doubles_in_order' )
-				self.reply_always_array   = gl_XML.is_attr_true( child, 'always_array' )
-				self.dimensions_in_reply  = gl_XML.is_attr_true( child, 'dimensions_in_reply' )
-
-			child = child.next
-
-
-		# Do some validation of the GLX protocol information.  As
-		# new tests are discovered, they should be added here.
-
-		for param in self.parameters:
-			if param.is_output and self.glx_rop != 0:
-				raise RuntimeError("Render / RenderLarge commands cannot have outputs (%s)." % (self.name))
-
-		return
-
-
-	def has_variable_size_request(self):
-		"""Determine if the GLX request packet is variable sized.
-
-		The GLX request packet is variable sized in several common
-		situations.
-		
-		1. The function has a non-output parameter that is counted
-		   by another parameter (e.g., the 'textures' parameter of
-		   glDeleteTextures).
-		   
-		2. The function has a non-output parameter whose count is
-		   determined by another parameter that is an enum (e.g., the
-		   'params' parameter of glLightfv).
-		   
-		3. The function has a non-output parameter that is an
-		   image.
-
-		4. The function must be hand-coded on the server.
-		"""
-
-		if self.glx_rop == 0:
-			return 0
-
-		if self.server_handcode or self.images:
-			return 1
-
-		for param in self.parameters:
-			if not param.is_output:
-				if param.counter or len(param.count_parameter_list):
-					return 1
-
-		return 0
-
-
-	def variable_length_parameter(self):
-		for param in self.parameters:
-			if not param.is_output:
-				if param.counter or len(param.count_parameter_list):
-					return param
-				
-		return None
 
+    def opcode_real_value(self):
+        """Get the true numeric value of the GLX opcode
 
-	def calculate_offsets(self):
-		if not self.offsets_calculated:
-			# Calculate the offset of the first function parameter
-			# in the GLX command packet.  This byte offset is
-			# measured from the end of the Render / RenderLarge
-			# header.  The offset for all non-pixel commends is
-			# zero.  The offset for pixel commands depends on the
-			# number of dimensions of the pixel data.
-
-			if len(self.images) and not self.images[0].is_output:
-				[dim, junk, junk, junk, junk] = self.images[0].get_dimensions()
-
-				# The base size is the size of the pixel pack info
-				# header used by images with the specified number
-				# of dimensions.
-
-				if dim <=  2:
-					offset = 20
-				elif dim <= 4:
-					offset = 36
-				else:
-					raise RuntimeError('Invalid number of dimensions %u for parameter "%s" in function "%s".' % (dim, self.image.name, self.name))
-			else:
-				offset = 0
-
-			for param in self.parameterIterateGlxSend():
-				if param.img_null_flag:
-					offset += 4
-
-				if param.name != self.img_reset:
-					param.offset = offset
-					if not param.is_variable_length() and not param.is_client_only:
-						offset += param.size()
-					
-				if self.pad_after( param ):
-					offset += 4
+        Behaves similarly to opcode_value, except for
+        X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
+        In these cases the value for the GLX opcode field (i.e.,
+        16 for X_GLXVendorPrivate or 17 for
+        X_GLXVendorPrivateWithReply) is returned.  For other 'single'
+        commands, the opcode for the command (e.g., 101 for
+        X_GLsop_NewList) is returned."""
 
+        if self.glx_vendorpriv != 0:
+            if self.needs_reply():
+                return 17
+            else:
+                return 16
+        else:
+            return self.opcode_value()
 
-			self.offsets_calculated = 1
-		return
 
+    def opcode_value(self):
+        """Get the unique protocol opcode for the glXFunction"""
 
-	def offset_of(self, param_name):
-		self.calculate_offsets()
-		return self.parameters_by_name[ param_name ].offset
+        if (self.glx_rop == 0) and self.vectorequiv:
+            equiv = self.context.functions_by_name[ self.vectorequiv ]
+            self.glx_rop = equiv.glx_rop
 
 
-	def parameterIterateGlxSend(self, include_variable_parameters = 1):
-		"""Create an iterator for parameters in GLX request order."""
+        if self.glx_rop != 0:
+            return self.glx_rop
+        elif self.glx_sop != 0:
+            return self.glx_sop
+        elif self.glx_vendorpriv != 0:
+            return self.glx_vendorpriv
+        else:
+            return -1
 
-		# The parameter lists are usually quite short, so it's easier
-		# (i.e., less code) to just generate a new list with the
-		# required elements than it is to create a new iterator class.
-		
-		temp = [ [],  [], [] ]
-		for param in self.parameters:
-			if param.is_output: continue
-
-			if param.is_variable_length():
-				temp[2].append( param )
-			elif not self.glx_doubles_in_order and param.is_64_bit():
-				temp[0].append( param )
-			else:
-				temp[1].append( param )
 
-		parameters = temp[0]
-		parameters.extend( temp[1] )
-		if include_variable_parameters:
-			parameters.extend( temp[2] )
-		return parameters.__iter__()
+    def opcode_rop_basename(self):
+        """Return either the name to be used for GLX protocol enum.
 
+        Returns either the name of the function or the name of the
+        name of the equivalent vector (e.g., glVertex3fv for
+        glVertex3f) function."""
 
-	def parameterIterateCounters(self):
-		temp = []
-		for name in self.counter_list:
-			temp.append( self.parameters_by_name[ name ] )
+        if self.vectorequiv == None:
+            return self.name
+        else:
+            return self.vectorequiv
 
-		return temp.__iter__()
 
+    def opcode_name(self):
+        """Get the unique protocol enum name for the glXFunction"""
 
-	def parameterIterateOutputs(self):
-		temp = []
-		for p in self.parameters:
-			if p.is_output:
-				temp.append( p )
+        if (self.glx_rop == 0) and self.vectorequiv:
+            equiv = self.context.functions_by_name[ self.vectorequiv ]
+            self.glx_rop = equiv.glx_rop
+            self.glx_doubles_in_order = equiv.glx_doubles_in_order
 
-		return temp
 
+        if self.glx_rop != 0:
+            return "X_GLrop_%s" % (self.opcode_rop_basename())
+        elif self.glx_sop != 0:
+            return "X_GLsop_%s" % (self.name)
+        elif self.glx_vendorpriv != 0:
+            return "X_GLvop_%s" % (self.name)
+        else:
+            raise RuntimeError('Function "%s" has no opcode.' % (self.name))
 
-	def command_fixed_length(self):
-		"""Return the length, in bytes as an integer, of the
-		fixed-size portion of the command."""
-
-		if len(self.parameters) == 0:
-			return 0
-		
-		self.calculate_offsets()
 
-		size = 0
-		for param in self.parameterIterateGlxSend(0):
-			if param.name != self.img_reset and not param.is_client_only:
-				if size == 0:
-					size = param.offset + param.size()
-				else:
-					size += param.size()
+    def opcode_vendor_name(self, name):
+        if name in self.glx_vendorpriv_names:
+            return "X_GLvop_%s" % (name)
+        else:
+            raise RuntimeError('Function "%s" has no VendorPrivate opcode.' % (name))
 
-				if self.pad_after( param ):
-					size += 4
 
-		for param in self.images:
-			if param.img_null_flag or param.is_output:
-				size += 4
+    def opcode_real_name(self):
+        """Get the true protocol enum name for the GLX opcode
 
-		return size
+        Behaves similarly to opcode_name, except for
+        X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
+        In these cases the string 'X_GLXVendorPrivate' or
+        'X_GLXVendorPrivateWithReply' is returned.  For other
+        single or render commands 'X_GLsop' or 'X_GLrop' plus the
+        name of the function returned."""
 
+        if self.glx_vendorpriv != 0:
+            if self.needs_reply():
+                return "X_GLXVendorPrivateWithReply"
+            else:
+                return "X_GLXVendorPrivate"
+        else:
+            return self.opcode_name()
 
-	def command_variable_length(self):
-		"""Return the length, as a string, of the variable-sized
-		portion of the command."""
 
-		size_string = ""
-		for p in self.parameterIterateGlxSend():
-			if (not p.is_output) and (p.is_variable_length() or p.is_image()):
-				# FIXME Replace the 1 in the size_string call
-				# FIXME w/0 to eliminate some un-needed parnes
-				# FIXME This would already be done, but it
-				# FIXME adds some extra diffs to the generated
-				# FIXME code.
+    def needs_reply(self):
+        try:
+            x = self._needs_reply
+        except Exception, e:
+            x = 0
+            if self.return_type != 'void':
+                x = 1
 
-				size_string = size_string + " + __GLX_PAD(%s)" % (p.size_string(1))
+            for param in self.parameters:
+                if param.is_output:
+                    x = 1
+                    break
 
-		return size_string
+            self._needs_reply = x
 
+        return x
 
-	def command_length(self):
-		size = self.command_fixed_length()
 
-		if self.glx_rop != 0:
-			size += 4
+    def pad_after(self, p):
+        """Returns the name of the field inserted after the
+        specified field to pad out the command header."""
 
-		size = ((size + 3) & ~3)
-		return "%u%s" % (size, self.command_variable_length())
-
-
-	def opcode_real_value(self):
-		"""Get the true numeric value of the GLX opcode
-		
-		Behaves similarly to opcode_value, except for
-		X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
-		In these cases the value for the GLX opcode field (i.e.,
-		16 for X_GLXVendorPrivate or 17 for
-		X_GLXVendorPrivateWithReply) is returned.  For other 'single'
-		commands, the opcode for the command (e.g., 101 for
-		X_GLsop_NewList) is returned."""
-
-		if self.glx_vendorpriv != 0:
-			if self.needs_reply():
-				return 17
-			else:
-				return 16
-		else:
-			return self.opcode_value()
+        for image in self.images:
+            if image.img_pad_dimensions:
+                if not image.height:
+                    if p.name == image.width:
+                        return "height"
+                    elif p.name == image.img_xoff:
+                        return "yoffset"
+                elif not image.extent:
+                    if p.name == image.depth:
+                        # Should this be "size4d"?
+                        return "extent"
+                    elif p.name == image.img_zoff:
+                        return "woffset"
 
+        return None
 
-	def opcode_value(self):
-		"""Get the unique protocol opcode for the glXFunction"""
 
-		if (self.glx_rop == 0) and self.vectorequiv:
-			equiv = self.context.functions_by_name[ self.vectorequiv ]
-			self.glx_rop = equiv.glx_rop
+    def has_different_protocol(self, name):
+        """Returns true if the named version of the function uses different protocol from the other versions.
 
+        Some functions, such as glDeleteTextures and
+        glDeleteTexturesEXT are functionally identical, but have
+        different protocol.  This function returns true if the
+        named function is an alias name and that named version uses
+        different protocol from the function that is aliased.
+        """
 
-		if self.glx_rop != 0:
-			return self.glx_rop
-		elif self.glx_sop != 0:
-			return self.glx_sop
-		elif self.glx_vendorpriv != 0:
-			return self.glx_vendorpriv
-		else:
-			return -1
-	
-
-	def opcode_rop_basename(self):
-		"""Return either the name to be used for GLX protocol enum.
-		
-		Returns either the name of the function or the name of the
-		name of the equivalent vector (e.g., glVertex3fv for
-		glVertex3f) function."""
-
-		if self.vectorequiv == None:
-			return self.name
-		else:
-			return self.vectorequiv
-
-
-	def opcode_name(self):
-		"""Get the unique protocol enum name for the glXFunction"""
-
-		if (self.glx_rop == 0) and self.vectorequiv:
-			equiv = self.context.functions_by_name[ self.vectorequiv ]
-			self.glx_rop = equiv.glx_rop
-			self.glx_doubles_in_order = equiv.glx_doubles_in_order
-
-
-		if self.glx_rop != 0:
-			return "X_GLrop_%s" % (self.opcode_rop_basename())
-		elif self.glx_sop != 0:
-			return "X_GLsop_%s" % (self.name)
-		elif self.glx_vendorpriv != 0:
-			return "X_GLvop_%s" % (self.name)
-		else:
-			raise RuntimeError('Function "%s" has no opcode.' % (self.name))
-
+        return (name in self.glx_vendorpriv_names) and self.glx_sop
 
-	def opcode_vendor_name(self, name):
-		if name in self.glx_vendorpriv_names:
-			return "X_GLvop_%s" % (name)
-		else:
-			raise RuntimeError('Function "%s" has no VendorPrivate opcode.' % (name))
-
-
-	def opcode_real_name(self):
-		"""Get the true protocol enum name for the GLX opcode
-		
-		Behaves similarly to opcode_name, except for
-		X_GLXVendorPrivate and X_GLXVendorPrivateWithReply commands.
-		In these cases the string 'X_GLXVendorPrivate' or
-		'X_GLXVendorPrivateWithReply' is returned.  For other
-		single or render commands 'X_GLsop' or 'X_GLrop' plus the
-		name of the function returned."""
 
-		if self.glx_vendorpriv != 0:
-			if self.needs_reply():
-				return "X_GLXVendorPrivateWithReply"
-			else:
-				return "X_GLXVendorPrivate"
-		else:
-			return self.opcode_name()
-
-
-	def needs_reply(self):
-		try:
-			x = self._needs_reply
-		except Exception, e:
-			x = 0
-			if self.return_type != 'void':
-				x = 1
-
-			for param in self.parameters:
-				if param.is_output:
-					x = 1
-					break
-
-			self._needs_reply = x
-
-		return x
-
-
-	def pad_after(self, p):
-		"""Returns the name of the field inserted after the
-		specified field to pad out the command header."""
+    def static_glx_name(self, name):
+        if self.has_different_protocol(name):
+            for n in self.glx_vendorpriv_names:
+                if n in self.static_entry_points:
+                    return n
 
-		for image in self.images:
-			if image.img_pad_dimensions:
-				if not image.height:
-					if p.name == image.width:
-						return "height"
-					elif p.name == image.img_xoff:
-						return "yoffset"
-				elif not image.extent:
-					if p.name == image.depth:
-						# Should this be "size4d"?
-						return "extent"
-					elif p.name == image.img_zoff:
-						return "woffset"
-
-		return None
-
-
-	def has_different_protocol(self, name):
-		"""Returns true if the named version of the function uses different protocol from the other versions.
-		
-		Some functions, such as glDeleteTextures and
-		glDeleteTexturesEXT are functionally identical, but have
-		different protocol.  This function returns true if the
-		named function is an alias name and that named version uses
-		different protocol from the function that is aliased.
-		"""
+        return self.static_name(name)
 
-		return (name in self.glx_vendorpriv_names) and self.glx_sop
 
+    def client_supported_for_indirect(self):
+        """Returns true if the function is supported on the client
+        side for indirect rendering."""
 
-	def static_glx_name(self, name):
-		if self.has_different_protocol(name):
-			for n in self.glx_vendorpriv_names:
-				if n in self.static_entry_points:
-					return n
-				
-		return self.static_name(name)
-
-
-	def client_supported_for_indirect(self):
-		"""Returns true if the function is supported on the client
-		side for indirect rendering."""
-
-		return not self.ignore and (self.offset != -1) and (self.glx_rop or self.glx_sop or self.glx_vendorpriv or self.vectorequiv or self.client_handcode)
+        return not self.ignore and (self.offset != -1) and (self.glx_rop or self.glx_sop or self.glx_vendorpriv or self.vectorequiv or self.client_handcode)
 
 
 class glx_function_iterator:
-	"""Class to iterate over a list of glXFunctions"""
+    """Class to iterate over a list of glXFunctions"""
 
-	def __init__(self, context):
-		self.iterator = context.functionIterateByOffset()
-		return
+    def __init__(self, context):
+        self.iterator = context.functionIterateByOffset()
+        return
 
 
-	def __iter__(self):
-		return self
+    def __iter__(self):
+        return self
 
 
-	def next(self):
-		f = self.iterator.next()
+    def next(self):
+        f = self.iterator.next()
 
-		if f.client_supported_for_indirect():
-			return f
-		else:
-			return self.next()
+        if f.client_supported_for_indirect():
+            return f
+        else:
+            return self.next()
 
 
 class glx_api(gl_XML.gl_api):
-	def functionIterateGlx(self):
-		return glx_function_iterator(self)
+    def functionIterateGlx(self):
+        return glx_function_iterator(self)