diff --git a/Tools/bgen/bgen/bgenBuffer.py b/Tools/bgen/bgen/bgenBuffer.py
index ee4a128..4b888d7 100644
--- a/Tools/bgen/bgen/bgenBuffer.py
+++ b/Tools/bgen/bgen/bgenBuffer.py
@@ -12,14 +12,14 @@
 
 # Map common types to their format characters
 type2format = {
-	'long': 'l',
-	'int': 'i',
-	'short': 'h',
-	'char': 'b',
-	'unsigned long': 'l',
-	'unsigned int': 'i',
-	'unsigned short': 'h',
-	'unsigned char': 'b',
+    'long': 'l',
+    'int': 'i',
+    'short': 'h',
+    'char': 'b',
+    'unsigned long': 'l',
+    'unsigned int': 'i',
+    'unsigned short': 'h',
+    'unsigned char': 'b',
 }
 
 
@@ -27,238 +27,238 @@
 
 
 class FixedInputOutputBufferType(InputOnlyType):
-	
-	"""Fixed buffer -- passed as (inbuffer, outbuffer)."""
+    
+    """Fixed buffer -- passed as (inbuffer, outbuffer)."""
 
-	def __init__(self, size, datatype = 'char', sizetype = 'int', sizeformat = None):
-		self.typeName = "Buffer"
-		self.size = str(size)
-		self.datatype = datatype
-		self.sizetype = sizetype
-		self.sizeformat = sizeformat or type2format[sizetype]
-		self.label_needed = 0
+    def __init__(self, size, datatype = 'char', sizetype = 'int', sizeformat = None):
+        self.typeName = "Buffer"
+        self.size = str(size)
+        self.datatype = datatype
+        self.sizetype = sizetype
+        self.sizeformat = sizeformat or type2format[sizetype]
+        self.label_needed = 0
 
-	def declare(self, name):
-		self.declareBuffer(name)
-		self.declareSize(name)
-	
-	def declareBuffer(self, name):
-		self.declareInputBuffer(name)
-		self.declareOutputBuffer(name)
-	
-	def declareInputBuffer(self, name):
-		Output("%s *%s__in__;", self.datatype, name)
-	
-	def declareOutputBuffer(self, name):
-		Output("%s %s__out__[%s];", self.datatype, name, self.size)
+    def declare(self, name):
+        self.declareBuffer(name)
+        self.declareSize(name)
+    
+    def declareBuffer(self, name):
+        self.declareInputBuffer(name)
+        self.declareOutputBuffer(name)
+    
+    def declareInputBuffer(self, name):
+        Output("%s *%s__in__;", self.datatype, name)
+    
+    def declareOutputBuffer(self, name):
+        Output("%s %s__out__[%s];", self.datatype, name, self.size)
 
-	def declareSize(self, name):
-		Output("%s %s__len__;", self.sizetype, name)
-		Output("int %s__in_len__;", name)
+    def declareSize(self, name):
+        Output("%s %s__len__;", self.sizetype, name)
+        Output("int %s__in_len__;", name)
 
-	def getargsFormat(self):
-		return "s#"
+    def getargsFormat(self):
+        return "s#"
 
-	def getargsArgs(self, name):
-		return "&%s__in__, &%s__in_len__" % (name, name)
-	
-	def getargsCheck(self, name):
-		Output("if (%s__in_len__ != %s)", name, self.size)
-		OutLbrace()
-		Output('PyErr_SetString(PyExc_TypeError, "buffer length should be %s");',
-		       self.size)
-		Output("goto %s__error__;", name)
-		self.label_needed = 1
-		OutRbrace()
-		self.transferSize(name)
-	
-	def transferSize(self, name):
-		Output("%s__len__ = %s__in_len__;", name, name)
+    def getargsArgs(self, name):
+        return "&%s__in__, &%s__in_len__" % (name, name)
+    
+    def getargsCheck(self, name):
+        Output("if (%s__in_len__ != %s)", name, self.size)
+        OutLbrace()
+        Output('PyErr_SetString(PyExc_TypeError, "buffer length should be %s");',
+               self.size)
+        Output("goto %s__error__;", name)
+        self.label_needed = 1
+        OutRbrace()
+        self.transferSize(name)
+    
+    def transferSize(self, name):
+        Output("%s__len__ = %s__in_len__;", name, name)
 
-	def passOutput(self, name):
-		return "%s__in__, %s__out__" % (name, name)
-	
-	def mkvalueFormat(self):
-		return "s#"
+    def passOutput(self, name):
+        return "%s__in__, %s__out__" % (name, name)
+    
+    def mkvalueFormat(self):
+        return "s#"
 
-	def mkvalueArgs(self, name):
-		return "%s__out__, (int)%s" % (name, self.size)
-	
-	def cleanup(self, name):
-		if self.label_needed:
-			DedentLevel()
-			Output(" %s__error__: ;", name)
-			IndentLevel()
+    def mkvalueArgs(self, name):
+        return "%s__out__, (int)%s" % (name, self.size)
+    
+    def cleanup(self, name):
+        if self.label_needed:
+            DedentLevel()
+            Output(" %s__error__: ;", name)
+            IndentLevel()
 
 
 class FixedCombinedInputOutputBufferType(FixedInputOutputBufferType):
-	
-	"""Like fixed buffer -- but same parameter is input and output."""
-	
-	def passOutput(self, name):
-		return "(%s *)memcpy(%s__out__, %s__in__, %s)" % \
-			(self.datatype, name,   name,     self.size)
+    
+    """Like fixed buffer -- but same parameter is input and output."""
+    
+    def passOutput(self, name):
+        return "(%s *)memcpy(%s__out__, %s__in__, %s)" % \
+            (self.datatype, name,   name,     self.size)
 
 
 class InputOnlyBufferMixIn(InputOnlyMixIn):
 
-	def declareOutputBuffer(self, name):
-		pass
+    def declareOutputBuffer(self, name):
+        pass
 
 
 class OutputOnlyBufferMixIn(OutputOnlyMixIn):
 
-	def declareInputBuffer(self, name):
-		pass
+    def declareInputBuffer(self, name):
+        pass
 
 class OptionalInputBufferMixIn:
-	
-	"""Add to input buffers if the buffer may be omitted: pass None in Python
-	and the C code will get a NULL pointer and zero size"""
-	
-	def getargsFormat(self):
-		return "z#"
+    
+    """Add to input buffers if the buffer may be omitted: pass None in Python
+    and the C code will get a NULL pointer and zero size"""
+    
+    def getargsFormat(self):
+        return "z#"
 
 
 class FixedInputBufferType(InputOnlyBufferMixIn, FixedInputOutputBufferType):
 
-	"""Fixed size input buffer -- passed without size information.
+    """Fixed size input buffer -- passed without size information.
 
-	Instantiate with the size as parameter.
-	"""
+    Instantiate with the size as parameter.
+    """
 
-	def passInput(self, name):
-		return "%s__in__" % name
+    def passInput(self, name):
+        return "%s__in__" % name
 
 class OptionalFixedInputBufferType(OptionalInputBufferMixIn, FixedInputBufferType):
-	pass
+    pass
 
 class FixedOutputBufferType(OutputOnlyBufferMixIn, FixedInputOutputBufferType):
 
-	"""Fixed size output buffer -- passed without size information.
+    """Fixed size output buffer -- passed without size information.
 
-	Instantiate with the size as parameter.
-	"""
+    Instantiate with the size as parameter.
+    """
 
-	def passOutput(self, name):
-		return "%s__out__" % name
+    def passOutput(self, name):
+        return "%s__out__" % name
 
 
 class VarInputBufferType(FixedInputBufferType):
 
-	"""Variable size input buffer -- passed as (buffer, size).
-	
-	Instantiate without size parameter.
-	"""
-	
-	def __init__(self, datatype = 'char', sizetype = 'int', sizeformat = None):
-		FixedInputBufferType.__init__(self, "0", datatype, sizetype, sizeformat)
-	
-	def getargsCheck(self, name):
-		Output("%s__len__ = %s__in_len__;", name, name)
-	
-	def passInput(self, name):
-		return "%s__in__, %s__len__" % (name, name)
-		
+    """Variable size input buffer -- passed as (buffer, size).
+    
+    Instantiate without size parameter.
+    """
+    
+    def __init__(self, datatype = 'char', sizetype = 'int', sizeformat = None):
+        FixedInputBufferType.__init__(self, "0", datatype, sizetype, sizeformat)
+    
+    def getargsCheck(self, name):
+        Output("%s__len__ = %s__in_len__;", name, name)
+    
+    def passInput(self, name):
+        return "%s__in__, %s__len__" % (name, name)
+        
 class ReverseInputBufferMixin:
-	""" Mixin for input buffers that are passed as (size, buffer) """
-	
-	def passInput(self, name):
-		return "%s__len__, %s__in__" % (name, name)
-		
+    """ Mixin for input buffers that are passed as (size, buffer) """
+    
+    def passInput(self, name):
+        return "%s__len__, %s__in__" % (name, name)
+        
 class OptionalVarInputBufferType(OptionalInputBufferMixIn, VarInputBufferType):
-	pass
-	
+    pass
+    
 # ----- PART 2: Structure buffers -----
 
 
 class StructInputOutputBufferType(FixedInputOutputBufferType):
-	
-	"""Structure buffer -- passed as a structure pointer.
+    
+    """Structure buffer -- passed as a structure pointer.
 
-	Instantiate with the struct type as parameter.
-	"""
-	
-	def __init__(self, type):
-		FixedInputOutputBufferType.__init__(self, "sizeof(%s)" % type)
-		self.typeName = self.type = type
-	
-	def declareInputBuffer(self, name):
-		Output("%s *%s__in__;", self.type, name)
-	
-	def declareSize(self, name):
-		Output("int %s__in_len__;", name)
-	
-	def declareOutputBuffer(self, name):
-		Output("%s %s__out__;", self.type, name)
-	
-	def getargsArgs(self, name):
-		return "(char **)&%s__in__, &%s__in_len__" % (name, name)
-	
-	def transferSize(self, name):
-		pass
-	
-	def passInput(self, name):
-		return "%s__in__" % name
-	
-	def passOutput(self, name):
-		return "%s__in__, &%s__out__" % (name, name)
-	
-	def mkvalueArgs(self, name):
-		return "(char *)&%s__out__, (int)%s" % (name, self.size)
+    Instantiate with the struct type as parameter.
+    """
+    
+    def __init__(self, type):
+        FixedInputOutputBufferType.__init__(self, "sizeof(%s)" % type)
+        self.typeName = self.type = type
+    
+    def declareInputBuffer(self, name):
+        Output("%s *%s__in__;", self.type, name)
+    
+    def declareSize(self, name):
+        Output("int %s__in_len__;", name)
+    
+    def declareOutputBuffer(self, name):
+        Output("%s %s__out__;", self.type, name)
+    
+    def getargsArgs(self, name):
+        return "(char **)&%s__in__, &%s__in_len__" % (name, name)
+    
+    def transferSize(self, name):
+        pass
+    
+    def passInput(self, name):
+        return "%s__in__" % name
+    
+    def passOutput(self, name):
+        return "%s__in__, &%s__out__" % (name, name)
+    
+    def mkvalueArgs(self, name):
+        return "(char *)&%s__out__, (int)%s" % (name, self.size)
 
 
 class StructCombinedInputOutputBufferType(StructInputOutputBufferType):
 
-	"""Like structure buffer -- but same parameter is input and output."""
-	
-	def passOutput(self, name):
-		return "(%s *)memcpy((char *)%s__out__, (char *)%s__in__, %s)" % \
-			(self.type,          name,              name,     self.size)
+    """Like structure buffer -- but same parameter is input and output."""
+    
+    def passOutput(self, name):
+        return "(%s *)memcpy((char *)%s__out__, (char *)%s__in__, %s)" % \
+            (self.type,          name,              name,     self.size)
 
 
 class StructInputBufferType(InputOnlyBufferMixIn, StructInputOutputBufferType):
 
-	"""Fixed size input buffer -- passed as a pointer to a structure.
+    """Fixed size input buffer -- passed as a pointer to a structure.
 
-	Instantiate with the struct type as parameter.
-	"""
+    Instantiate with the struct type as parameter.
+    """
 
 
 class StructByValueBufferType(StructInputBufferType):
 
-	"""Fixed size input buffer -- passed as a structure BY VALUE.
+    """Fixed size input buffer -- passed as a structure BY VALUE.
 
-	Instantiate with the struct type as parameter.
-	"""
+    Instantiate with the struct type as parameter.
+    """
 
-	def passInput(self, name):
-		return "*%s__in__" % name
+    def passInput(self, name):
+        return "*%s__in__" % name
 
 
 class StructOutputBufferType(OutputOnlyBufferMixIn, StructInputOutputBufferType):
 
-	"""Fixed size output buffer -- passed as a pointer to a structure.
+    """Fixed size output buffer -- passed as a pointer to a structure.
 
-	Instantiate with the struct type as parameter.
-	"""
-	
-	def declareSize(self, name):
-		pass
+    Instantiate with the struct type as parameter.
+    """
+    
+    def declareSize(self, name):
+        pass
 
-	def passOutput(self, name):
-		return "&%s__out__" % name
+    def passOutput(self, name):
+        return "&%s__out__" % name
 
 
 class ArrayOutputBufferType(OutputOnlyBufferMixIn, StructInputOutputBufferType):
 
-	"""Fixed size output buffer -- declared as a typedef, passed as an array.
+    """Fixed size output buffer -- declared as a typedef, passed as an array.
 
-	Instantiate with the struct type as parameter.
-	"""
-	
-	def declareSize(self, name):
-		pass
+    Instantiate with the struct type as parameter.
+    """
+    
+    def declareSize(self, name):
+        pass
 
-	def passOutput(self, name):
-		return "%s__out__" % name
+    def passOutput(self, name):
+        return "%s__out__" % name
diff --git a/Tools/bgen/bgen/bgenGenerator.py b/Tools/bgen/bgen/bgenGenerator.py
index 1c19388..f3cdfce 100644
--- a/Tools/bgen/bgen/bgenGenerator.py
+++ b/Tools/bgen/bgen/bgenGenerator.py
@@ -15,260 +15,260 @@
 
 class BaseFunctionGenerator:
 
-	def __init__(self, name, condition=None):
-		if DEBUG: print "<--", name
-		self.name = name
-		self.prefix = name
-		self.objecttype = "PyObject" # Type of _self argument to function
-		self.condition = condition
+    def __init__(self, name, condition=None):
+        if DEBUG: print "<--", name
+        self.name = name
+        self.prefix = name
+        self.objecttype = "PyObject" # Type of _self argument to function
+        self.condition = condition
 
-	def setprefix(self, prefix):
-		self.prefix = prefix
+    def setprefix(self, prefix):
+        self.prefix = prefix
 
-	def generate(self):
-		if DEBUG: print "-->", self.name
-		if self.condition:
-			Output()
-			Output(self.condition)
-		self.functionheader()
-		self.functionbody()
-		self.functiontrailer()
-		if self.condition:
-			Output("#endif")
+    def generate(self):
+        if DEBUG: print "-->", self.name
+        if self.condition:
+            Output()
+            Output(self.condition)
+        self.functionheader()
+        self.functionbody()
+        self.functiontrailer()
+        if self.condition:
+            Output("#endif")
 
-	def functionheader(self):
-		Output()
-		Output("static PyObject *%s_%s(%s *_self, PyObject *_args)",
-		       self.prefix, self.name, self.objecttype)
-		OutLbrace()
-		Output("PyObject *_res = NULL;")
+    def functionheader(self):
+        Output()
+        Output("static PyObject *%s_%s(%s *_self, PyObject *_args)",
+               self.prefix, self.name, self.objecttype)
+        OutLbrace()
+        Output("PyObject *_res = NULL;")
 
-	def functionbody(self):
-		Output("/* XXX To be provided */")
+    def functionbody(self):
+        Output("/* XXX To be provided */")
 
-	def functiontrailer(self):
-		OutRbrace()
+    def functiontrailer(self):
+        OutRbrace()
 
-	def reference(self, name = None):
-		if name is None:
-			name = self.name
-		docstring = self.docstring()
-		if self.condition:
-			Output()
-			Output(self.condition)		
-		Output("{\"%s\", (PyCFunction)%s_%s, 1,", name, self.prefix, self.name)
-		Output(" PyDoc_STR(%s)},", stringify(docstring))
-		if self.condition:
-			Output("#endif")
+    def reference(self, name = None):
+        if name is None:
+            name = self.name
+        docstring = self.docstring()
+        if self.condition:
+            Output()
+            Output(self.condition)      
+        Output("{\"%s\", (PyCFunction)%s_%s, 1,", name, self.prefix, self.name)
+        Output(" PyDoc_STR(%s)},", stringify(docstring))
+        if self.condition:
+            Output("#endif")
 
-	def docstring(self):
-		return None
+    def docstring(self):
+        return None
 
-	def __cmp__(self, other):
-		if not hasattr(other, 'name'):
-			return cmp(id(self), id(other))
-		return cmp(self.name, other.name)
+    def __cmp__(self, other):
+        if not hasattr(other, 'name'):
+            return cmp(id(self), id(other))
+        return cmp(self.name, other.name)
 
 _stringify_map = {'\n': '\\n', '\t': '\\t', '\r': '\\r', '\b': '\\b',
                   '\e': '\\e', '\a': '\\a', '\f': '\\f', '"': '\\"'}
 def stringify(str):
-	if str is None: return "NULL"
-	res = '"'
-	map = _stringify_map
-	for c in str:
-		if map.has_key(c): res = res + map[c]
-		elif ' ' <= c <= '~': res = res + c
-		else: res = res + '\\%03o' % ord(c)
-	res = res + '"'
-	return res
+    if str is None: return "NULL"
+    res = '"'
+    map = _stringify_map
+    for c in str:
+        if map.has_key(c): res = res + map[c]
+        elif ' ' <= c <= '~': res = res + c
+        else: res = res + '\\%03o' % ord(c)
+    res = res + '"'
+    return res
 
 
 class ManualGenerator(BaseFunctionGenerator):
 
-	def __init__(self, name, body, condition=None):
-		BaseFunctionGenerator.__init__(self, name, condition=condition)
-		self.body = body
+    def __init__(self, name, body, condition=None):
+        BaseFunctionGenerator.__init__(self, name, condition=condition)
+        self.body = body
 
-	def functionbody(self):
-		Output("%s", self.body)
-		
-	def setselftype(self, selftype, itselftype):
-		self.objecttype = selftype
-		self.itselftype = itselftype
+    def functionbody(self):
+        Output("%s", self.body)
+        
+    def setselftype(self, selftype, itselftype):
+        self.objecttype = selftype
+        self.itselftype = itselftype
 
 
 class FunctionGenerator(BaseFunctionGenerator):
 
-	def __init__(self, returntype, name, *argumentList, **conditionlist):
-		BaseFunctionGenerator.__init__(self, name, **conditionlist)
-		self.returntype = returntype
-		self.argumentList = []
-		self.setreturnvar()
-		self.parseArgumentList(argumentList)
-		self.prefix     = "XXX"    # Will be changed by setprefix() call
-		self.itselftype = None     # Type of _self->ob_itself, if defined
+    def __init__(self, returntype, name, *argumentList, **conditionlist):
+        BaseFunctionGenerator.__init__(self, name, **conditionlist)
+        self.returntype = returntype
+        self.argumentList = []
+        self.setreturnvar()
+        self.parseArgumentList(argumentList)
+        self.prefix     = "XXX"    # Will be changed by setprefix() call
+        self.itselftype = None     # Type of _self->ob_itself, if defined
 
-	def setreturnvar(self):
-		if self.returntype:
-			self.rv = self.makereturnvar()
-			self.argumentList.append(self.rv)
-		else:
-			self.rv = None
-	
-	def makereturnvar(self):
-		return Variable(self.returntype, "_rv", OutMode)
+    def setreturnvar(self):
+        if self.returntype:
+            self.rv = self.makereturnvar()
+            self.argumentList.append(self.rv)
+        else:
+            self.rv = None
+    
+    def makereturnvar(self):
+        return Variable(self.returntype, "_rv", OutMode)
 
-	def setselftype(self, selftype, itselftype):
-		self.objecttype = selftype
-		self.itselftype = itselftype
+    def setselftype(self, selftype, itselftype):
+        self.objecttype = selftype
+        self.itselftype = itselftype
 
-	def parseArgumentList(self, argumentList):
-		iarg = 0
-		for type, name, mode in argumentList:
-			iarg = iarg + 1
-			if name is None: name = "_arg%d" % iarg
-			arg = Variable(type, name, mode)
-			self.argumentList.append(arg)
-	
-	def docstring(self):
-		input = []
-		output = []
-		for arg in self.argumentList:
-			if arg.flags == ErrorMode or arg.flags == SelfMode:
-				continue
-			if arg.type == None:
-				str = 'void'
-			else:
-				if hasattr(arg.type, 'typeName'):
-					typeName = arg.type.typeName
-					if typeName is None: # Suppressed type
-						continue
-				else:
-					typeName = "?"
-					print "Nameless type", arg.type
-					
-				str = typeName + ' ' + arg.name
-			if arg.mode in (InMode, InOutMode):
-				input.append(str)
-			if arg.mode in (InOutMode, OutMode):
-				output.append(str)
-		if not input:
-			instr = "()"
-		else:
-			instr = "(%s)" % ", ".join(input)
-		if not output or output == ["void"]:
-			outstr = "None"
-		else:
-			outstr = "(%s)" % ", ".join(output)
-		return instr + " -> " + outstr
-	
-	def functionbody(self):
-		self.declarations()
-		self.precheck()
-		self.getargs()
-		self.callit()
-		self.checkit()
-		self.returnvalue()
+    def parseArgumentList(self, argumentList):
+        iarg = 0
+        for type, name, mode in argumentList:
+            iarg = iarg + 1
+            if name is None: name = "_arg%d" % iarg
+            arg = Variable(type, name, mode)
+            self.argumentList.append(arg)
+    
+    def docstring(self):
+        input = []
+        output = []
+        for arg in self.argumentList:
+            if arg.flags == ErrorMode or arg.flags == SelfMode:
+                continue
+            if arg.type == None:
+                str = 'void'
+            else:
+                if hasattr(arg.type, 'typeName'):
+                    typeName = arg.type.typeName
+                    if typeName is None: # Suppressed type
+                        continue
+                else:
+                    typeName = "?"
+                    print "Nameless type", arg.type
+                    
+                str = typeName + ' ' + arg.name
+            if arg.mode in (InMode, InOutMode):
+                input.append(str)
+            if arg.mode in (InOutMode, OutMode):
+                output.append(str)
+        if not input:
+            instr = "()"
+        else:
+            instr = "(%s)" % ", ".join(input)
+        if not output or output == ["void"]:
+            outstr = "None"
+        else:
+            outstr = "(%s)" % ", ".join(output)
+        return instr + " -> " + outstr
+    
+    def functionbody(self):
+        self.declarations()
+        self.precheck()
+        self.getargs()
+        self.callit()
+        self.checkit()
+        self.returnvalue()
 
-	def declarations(self):
-		for arg in self.argumentList:
-			arg.declare()
+    def declarations(self):
+        for arg in self.argumentList:
+            arg.declare()
 
-	def getargs(self):
-		fmt = ""
-		lst = ""
-		sep = ",\n" + ' '*len("if (!PyArg_ParseTuple(")
-		for arg in self.argumentList:
-			if arg.flags == SelfMode:
-				continue
-			if arg.mode in (InMode, InOutMode):
-				fmt = fmt + arg.getargsFormat()
-				args = arg.getargsArgs()
-				if args:
-					lst = lst + sep + args
-		Output("if (!PyArg_ParseTuple(_args, \"%s\"%s))", fmt, lst)
-		IndentLevel()
-		Output("return NULL;")
-		DedentLevel()
-		for arg in self.argumentList:
-			if arg.flags == SelfMode:
-				continue
-			if arg.mode in (InMode, InOutMode):
-				arg.getargsCheck()
-	
-	def precheck(self):
-		pass
+    def getargs(self):
+        fmt = ""
+        lst = ""
+        sep = ",\n" + ' '*len("if (!PyArg_ParseTuple(")
+        for arg in self.argumentList:
+            if arg.flags == SelfMode:
+                continue
+            if arg.mode in (InMode, InOutMode):
+                fmt = fmt + arg.getargsFormat()
+                args = arg.getargsArgs()
+                if args:
+                    lst = lst + sep + args
+        Output("if (!PyArg_ParseTuple(_args, \"%s\"%s))", fmt, lst)
+        IndentLevel()
+        Output("return NULL;")
+        DedentLevel()
+        for arg in self.argumentList:
+            if arg.flags == SelfMode:
+                continue
+            if arg.mode in (InMode, InOutMode):
+                arg.getargsCheck()
+    
+    def precheck(self):
+        pass
 
-	def callit(self):
-		args = ""
-		if self.rv:
-			s = "%s = %s(" % (self.rv.name, self.name)
-		else:
-			s = "%s(" % self.name
-		sep = ",\n" + ' '*len(s)
-		for arg in self.argumentList:
-			if arg is self.rv:
-				continue
-			s = arg.passArgument()
-			if args: s = sep + s
-			args = args + s
-		if self.rv:
-			Output("%s = %s(%s);",
-			       self.rv.name, self.name, args)
-		else:
-			Output("%s(%s);", self.name, args)
+    def callit(self):
+        args = ""
+        if self.rv:
+            s = "%s = %s(" % (self.rv.name, self.name)
+        else:
+            s = "%s(" % self.name
+        sep = ",\n" + ' '*len(s)
+        for arg in self.argumentList:
+            if arg is self.rv:
+                continue
+            s = arg.passArgument()
+            if args: s = sep + s
+            args = args + s
+        if self.rv:
+            Output("%s = %s(%s);",
+                   self.rv.name, self.name, args)
+        else:
+            Output("%s(%s);", self.name, args)
 
-	def checkit(self):
-		for arg in self.argumentList:
-			arg.errorCheck()
+    def checkit(self):
+        for arg in self.argumentList:
+            arg.errorCheck()
 
-	def returnvalue(self):
-		fmt = ""
-		lst = ""
-		sep = ",\n" + ' '*len("return Py_BuildValue(")
-		for arg in self.argumentList:
-			if not arg: continue
-			if arg.flags == ErrorMode: continue
-			if arg.mode in (OutMode, InOutMode):
-				fmt = fmt + arg.mkvalueFormat()
-				lst = lst + sep + arg.mkvalueArgs()
-		if fmt == "":
-			Output("Py_INCREF(Py_None);")
-			Output("_res = Py_None;");
-		else:
-			Output("_res = Py_BuildValue(\"%s\"%s);", fmt, lst)
-		tmp = self.argumentList[:]
-		tmp.reverse()
-		for arg in tmp:
-			if not arg: continue
-			arg.cleanup()
-		Output("return _res;")
+    def returnvalue(self):
+        fmt = ""
+        lst = ""
+        sep = ",\n" + ' '*len("return Py_BuildValue(")
+        for arg in self.argumentList:
+            if not arg: continue
+            if arg.flags == ErrorMode: continue
+            if arg.mode in (OutMode, InOutMode):
+                fmt = fmt + arg.mkvalueFormat()
+                lst = lst + sep + arg.mkvalueArgs()
+        if fmt == "":
+            Output("Py_INCREF(Py_None);")
+            Output("_res = Py_None;");
+        else:
+            Output("_res = Py_BuildValue(\"%s\"%s);", fmt, lst)
+        tmp = self.argumentList[:]
+        tmp.reverse()
+        for arg in tmp:
+            if not arg: continue
+            arg.cleanup()
+        Output("return _res;")
 
 
 class MethodGenerator(FunctionGenerator):
 
-	def parseArgumentList(self, args):
-		a0, args = args[0], args[1:]
-		t0, n0, m0 = a0
-		if m0 != InMode:
-			raise ValueError, "method's 'self' must be 'InMode'"
-		self.itself = Variable(t0, "_self->ob_itself", SelfMode)
-		self.argumentList.append(self.itself)
-		FunctionGenerator.parseArgumentList(self, args)
+    def parseArgumentList(self, args):
+        a0, args = args[0], args[1:]
+        t0, n0, m0 = a0
+        if m0 != InMode:
+            raise ValueError, "method's 'self' must be 'InMode'"
+        self.itself = Variable(t0, "_self->ob_itself", SelfMode)
+        self.argumentList.append(self.itself)
+        FunctionGenerator.parseArgumentList(self, args)
 
 
 def _test():
-	void = None
-	eggs = FunctionGenerator(void, "eggs",
-				 (stringptr, 'cmd', InMode),
-				 (int, 'x', InMode),
-				 (double, 'y', InOutMode),
-				 (int, 'status', ErrorMode),
-				 )
-	eggs.setprefix("spam")
-	print "/* START */"
-	eggs.generate()
+    void = None
+    eggs = FunctionGenerator(void, "eggs",
+                 (stringptr, 'cmd', InMode),
+                 (int, 'x', InMode),
+                 (double, 'y', InOutMode),
+                 (int, 'status', ErrorMode),
+                 )
+    eggs.setprefix("spam")
+    print "/* START */"
+    eggs.generate()
 
 
 if __name__ == "__main__":
-	_test()
+    _test()
diff --git a/Tools/bgen/bgen/bgenGeneratorGroup.py b/Tools/bgen/bgen/bgenGeneratorGroup.py
index 784bf69..d82ab53 100644
--- a/Tools/bgen/bgen/bgenGeneratorGroup.py
+++ b/Tools/bgen/bgen/bgenGeneratorGroup.py
@@ -2,39 +2,39 @@
 
 class GeneratorGroup:
 
-	def __init__(self, prefix):
-		self.prefix = prefix
-		self.generators = []
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self.generators = []
 
-	def add(self, g, dupcheck=0):
-		if dupcheck:
-			if g in self.generators:
-				print 'DUP', g.name
-				return
-		g.setprefix(self.prefix)
-		self.generators.append(g)
+    def add(self, g, dupcheck=0):
+        if dupcheck:
+            if g in self.generators:
+                print 'DUP', g.name
+                return
+        g.setprefix(self.prefix)
+        self.generators.append(g)
 
-	def generate(self):
-		for g in self.generators:
-			g.generate()
-		Output()
-		Output("static PyMethodDef %s_methods[] = {", self.prefix)
-		IndentLevel()
-		for g in self.generators:
-			g.reference()
-		Output("{NULL, NULL, 0}")
-		DedentLevel()
-		Output("};")
+    def generate(self):
+        for g in self.generators:
+            g.generate()
+        Output()
+        Output("static PyMethodDef %s_methods[] = {", self.prefix)
+        IndentLevel()
+        for g in self.generators:
+            g.reference()
+        Output("{NULL, NULL, 0}")
+        DedentLevel()
+        Output("};")
 
 
 def _test():
-	void = None
-	from bgenGenerator import FunctionGenerator
-	group = GeneratorGroup("spam")
-	eggs = FunctionGenerator(void, "eggs")
-	group.add(eggs)
-	print "/* START */"
-	group.generate()
+    void = None
+    from bgenGenerator import FunctionGenerator
+    group = GeneratorGroup("spam")
+    eggs = FunctionGenerator(void, "eggs")
+    group.add(eggs)
+    print "/* START */"
+    group.generate()
 
 if __name__ == "__main__":
-	_test()
+    _test()
diff --git a/Tools/bgen/bgen/bgenHeapBuffer.py b/Tools/bgen/bgen/bgenHeapBuffer.py
index 1b16d55..9bfc5a1 100644
--- a/Tools/bgen/bgen/bgenHeapBuffer.py
+++ b/Tools/bgen/bgen/bgenHeapBuffer.py
@@ -7,105 +7,105 @@
 
 class HeapInputOutputBufferType(FixedInputOutputBufferType):
 
-	"""Input-output buffer allocated on the heap -- passed as (inbuffer, outbuffer, size).
+    """Input-output buffer allocated on the heap -- passed as (inbuffer, outbuffer, size).
 
-	Instantiate without parameters.
-	Call from Python with input buffer.
-	"""
+    Instantiate without parameters.
+    Call from Python with input buffer.
+    """
 
-	def __init__(self, datatype = 'char', sizetype = 'int', sizeformat = None):
-		FixedInputOutputBufferType.__init__(self, "0", datatype, sizetype, sizeformat)
+    def __init__(self, datatype = 'char', sizetype = 'int', sizeformat = None):
+        FixedInputOutputBufferType.__init__(self, "0", datatype, sizetype, sizeformat)
 
-	def declareOutputBuffer(self, name):
-		Output("%s *%s__out__;", self.datatype, name)
+    def declareOutputBuffer(self, name):
+        Output("%s *%s__out__;", self.datatype, name)
 
-	def getargsCheck(self, name):
-		Output("if ((%s__out__ = malloc(%s__in_len__)) == NULL)", name, name)
-		OutLbrace()
-		Output('PyErr_NoMemory();')
-		Output("goto %s__error__;", name)
-		self.label_needed = 1
-		OutRbrace()
-		Output("%s__len__ = %s__in_len__;", name, name)
+    def getargsCheck(self, name):
+        Output("if ((%s__out__ = malloc(%s__in_len__)) == NULL)", name, name)
+        OutLbrace()
+        Output('PyErr_NoMemory();')
+        Output("goto %s__error__;", name)
+        self.label_needed = 1
+        OutRbrace()
+        Output("%s__len__ = %s__in_len__;", name, name)
 
-	def passOutput(self, name):
-		return "%s__in__, %s__out__, (%s)%s__len__" % \
-			(name, name, self.sizetype, name)
+    def passOutput(self, name):
+        return "%s__in__, %s__out__, (%s)%s__len__" % \
+            (name, name, self.sizetype, name)
 
-	def mkvalueArgs(self, name):
-		return "%s__out__, (int)%s__len__" % (name, name)
+    def mkvalueArgs(self, name):
+        return "%s__out__, (int)%s__len__" % (name, name)
 
-	def cleanup(self, name):
-		Output("free(%s__out__);", name)
-		FixedInputOutputBufferType.cleanup(self, name)
+    def cleanup(self, name):
+        Output("free(%s__out__);", name)
+        FixedInputOutputBufferType.cleanup(self, name)
 
 
 class VarHeapInputOutputBufferType(HeapInputOutputBufferType):
 
-	"""same as base class, but passed as (inbuffer, outbuffer, &size)"""
-	
-	def passOutput(self, name):
-		return "%s__in__, %s__out__, &%s__len__" % (name, name, name)
+    """same as base class, but passed as (inbuffer, outbuffer, &size)"""
+    
+    def passOutput(self, name):
+        return "%s__in__, %s__out__, &%s__len__" % (name, name, name)
 
 
 class HeapCombinedInputOutputBufferType(HeapInputOutputBufferType):
 
-	"""same as base class, but passed as (inoutbuffer, size)"""
-	
-	def passOutput(self, name):
-		return "(%s *)memcpy(%s__out__, %s__in__, %s__len__)" % \
-			(self.datatype, name,   name,     name)
+    """same as base class, but passed as (inoutbuffer, size)"""
+    
+    def passOutput(self, name):
+        return "(%s *)memcpy(%s__out__, %s__in__, %s__len__)" % \
+            (self.datatype, name,   name,     name)
 
 
 class VarHeapCombinedInputOutputBufferType(HeapInputOutputBufferType):
 
-	"""same as base class, but passed as (inoutbuffer, &size)"""
-	
-	def passOutput(self, name):
-		return "(%s *)memcpy(%s__out__, %s__in__, &%s__len__)" % \
-			(self.datatype, name,   name,      name)
+    """same as base class, but passed as (inoutbuffer, &size)"""
+    
+    def passOutput(self, name):
+        return "(%s *)memcpy(%s__out__, %s__in__, &%s__len__)" % \
+            (self.datatype, name,   name,      name)
 
 
 class HeapOutputBufferType(OutputOnlyMixIn, HeapInputOutputBufferType):
 
-	"""Output buffer allocated on the heap -- passed as (buffer, size).
+    """Output buffer allocated on the heap -- passed as (buffer, size).
 
-	Instantiate without parameters.
-	Call from Python with buffer size.
-	"""
-	
-	def declareInputBuffer(self, name):
-		pass
-	
-	def getargsFormat(self):
-		return "i"
-	
-	def getargsArgs(self, name):
-		return "&%s__in_len__" % name
-	
-	def passOutput(self, name):
-		return "%s__out__, %s__len__" % (name, name)
+    Instantiate without parameters.
+    Call from Python with buffer size.
+    """
+    
+    def declareInputBuffer(self, name):
+        pass
+    
+    def getargsFormat(self):
+        return "i"
+    
+    def getargsArgs(self, name):
+        return "&%s__in_len__" % name
+    
+    def passOutput(self, name):
+        return "%s__out__, %s__len__" % (name, name)
 
 
 class VarHeapOutputBufferType(HeapOutputBufferType):
 
-	"""Output buffer allocated on the heap -- passed as (buffer, &size).
+    """Output buffer allocated on the heap -- passed as (buffer, &size).
 
-	Instantiate without parameters.
-	Call from Python with buffer size.
-	"""
+    Instantiate without parameters.
+    Call from Python with buffer size.
+    """
 
-	def passOutput(self, name):
-		return "%s__out__, &%s__len__" % (name, name)
+    def passOutput(self, name):
+        return "%s__out__, &%s__len__" % (name, name)
 
 
 class VarVarHeapOutputBufferType(VarHeapOutputBufferType):
 
-	"""Output buffer allocated on the heap -- passed as (buffer, size, &size).
+    """Output buffer allocated on the heap -- passed as (buffer, size, &size).
 
-	Instantiate without parameters.
-	Call from Python with buffer size.
-	"""
+    Instantiate without parameters.
+    Call from Python with buffer size.
+    """
 
-	def passOutput(self, name):
-		return "%s__out__, %s__len__, &%s__len__" % (name, name, name)
+    def passOutput(self, name):
+        return "%s__out__, %s__len__, &%s__len__" % (name, name, name)
diff --git a/Tools/bgen/bgen/bgenModule.py b/Tools/bgen/bgen/bgenModule.py
index 1a182a7..3e26b16 100644
--- a/Tools/bgen/bgen/bgenModule.py
+++ b/Tools/bgen/bgen/bgenModule.py
@@ -3,92 +3,92 @@
 
 class Module(GeneratorGroup):
 
-	def __init__(self, name, prefix = None,
-		     includestuff = None,
-		     finalstuff = None,
-		     initstuff = None,
-		     variablestuff = None,
-		     longname = None):
-		GeneratorGroup.__init__(self, prefix or name)
-		self.name = name
-		if longname:
-			self.longname = longname
-		else:
-			self.longname = name
-		self.includestuff = includestuff
-		self.initstuff = initstuff
-		self.finalstuff = finalstuff
-		self.variablestuff = variablestuff
-		self.typeobjects = []
+    def __init__(self, name, prefix = None,
+             includestuff = None,
+             finalstuff = None,
+             initstuff = None,
+             variablestuff = None,
+             longname = None):
+        GeneratorGroup.__init__(self, prefix or name)
+        self.name = name
+        if longname:
+            self.longname = longname
+        else:
+            self.longname = name
+        self.includestuff = includestuff
+        self.initstuff = initstuff
+        self.finalstuff = finalstuff
+        self.variablestuff = variablestuff
+        self.typeobjects = []
 
-	def addobject(self, od):
-		self.generators.append(od)
-		self.typeobjects.append(od)
-		od.setmodulename(self.longname)
+    def addobject(self, od):
+        self.generators.append(od)
+        self.typeobjects.append(od)
+        od.setmodulename(self.longname)
 
-	def generate(self):
-		OutHeader1("Module " + self.name)
-		Output("#include \"Python.h\"")
-		Output()
+    def generate(self):
+        OutHeader1("Module " + self.name)
+        Output("#include \"Python.h\"")
+        Output()
 
-		if self.includestuff:
-			Output()
-			Output("%s", self.includestuff)
+        if self.includestuff:
+            Output()
+            Output("%s", self.includestuff)
 
-		self.declareModuleVariables()
+        self.declareModuleVariables()
 
-		GeneratorGroup.generate(self)
-		
-		if self.finalstuff:
-			Output()
-			Output("%s", self.finalstuff)
+        GeneratorGroup.generate(self)
+        
+        if self.finalstuff:
+            Output()
+            Output("%s", self.finalstuff)
 
-		Output()
-		Output("void init%s(void)", self.name)
-		OutLbrace()
-		Output("PyObject *m;")
-		Output("PyObject *d;")
-		Output()
+        Output()
+        Output("void init%s(void)", self.name)
+        OutLbrace()
+        Output("PyObject *m;")
+        Output("PyObject *d;")
+        Output()
 
-		if self.initstuff:
-			Output("%s", self.initstuff)
-			Output()
+        if self.initstuff:
+            Output("%s", self.initstuff)
+            Output()
 
-		Output("m = Py_InitModule(\"%s\", %s_methods);",
-		       self.name, self.prefix)
-		Output("d = PyModule_GetDict(m);")
-		self.createModuleVariables()
-		OutRbrace()
-		OutHeader1("End module " + self.name)
+        Output("m = Py_InitModule(\"%s\", %s_methods);",
+               self.name, self.prefix)
+        Output("d = PyModule_GetDict(m);")
+        self.createModuleVariables()
+        OutRbrace()
+        OutHeader1("End module " + self.name)
 
-	def declareModuleVariables(self):
-		self.errorname = self.prefix + "_Error"
-		Output("static PyObject *%s;", self.errorname)
+    def declareModuleVariables(self):
+        self.errorname = self.prefix + "_Error"
+        Output("static PyObject *%s;", self.errorname)
 
-	def createModuleVariables(self):
-		Output("""%s = %s;""", self.errorname, self.exceptionInitializer())
-		Output("""if (%s == NULL ||""", self.errorname)
-		Output("""    PyDict_SetItemString(d, "Error", %s) != 0)""",
-		                                               self.errorname)
-		IndentLevel()
-		Output("""return;""")
-		DedentLevel()
-		for tp in self.typeobjects:
-			tp.outputTypeObjectInitializer()
-		if self.variablestuff:
-			Output("%s", self.variablestuff)
-			Output()
+    def createModuleVariables(self):
+        Output("""%s = %s;""", self.errorname, self.exceptionInitializer())
+        Output("""if (%s == NULL ||""", self.errorname)
+        Output("""    PyDict_SetItemString(d, "Error", %s) != 0)""",
+                                                       self.errorname)
+        IndentLevel()
+        Output("""return;""")
+        DedentLevel()
+        for tp in self.typeobjects:
+            tp.outputTypeObjectInitializer()
+        if self.variablestuff:
+            Output("%s", self.variablestuff)
+            Output()
 
-	def exceptionInitializer(self):
-		return """PyErr_NewException("%s.Error", NULL, NULL)""" % self.name
+    def exceptionInitializer(self):
+        return """PyErr_NewException("%s.Error", NULL, NULL)""" % self.name
 
 
 def _test():
-	from bgenGenerator import FunctionGenerator
-	m = Module("spam", "", "#include <stdio.h>")
-	g = FunctionGenerator(None, "bacon")
-	m.add(g)
-	m.generate()
+    from bgenGenerator import FunctionGenerator
+    m = Module("spam", "", "#include <stdio.h>")
+    g = FunctionGenerator(None, "bacon")
+    m.add(g)
+    m.generate()
 
 if __name__ == "__main__":
-	_test()
+    _test()
diff --git a/Tools/bgen/bgen/bgenObjectDefinition.py b/Tools/bgen/bgen/bgenObjectDefinition.py
index 986b407..40435ad 100644
--- a/Tools/bgen/bgen/bgenObjectDefinition.py
+++ b/Tools/bgen/bgen/bgenObjectDefinition.py
@@ -2,485 +2,485 @@
 from bgenGeneratorGroup import GeneratorGroup
 
 class ObjectDefinition(GeneratorGroup):
-	"Spit out code that together defines a new Python object type"
-	basechain = "NULL"
-	tp_flags = "Py_TPFLAGS_DEFAULT"
-	basetype = None
+    "Spit out code that together defines a new Python object type"
+    basechain = "NULL"
+    tp_flags = "Py_TPFLAGS_DEFAULT"
+    basetype = None
 
-	def __init__(self, name, prefix, itselftype):
-		"""ObjectDefinition constructor.  May be extended, but do not override.
-		
-		- name: the object's official name, e.g. 'SndChannel'.
-		- prefix: the prefix used for the object's functions and data, e.g. 'SndCh'.
-		- itselftype: the C type actually contained in the object, e.g. 'SndChannelPtr'.
-		
-		XXX For official Python data types, rules for the 'Py' prefix are a problem.
-		"""
-		
-		GeneratorGroup.__init__(self, prefix or name)
-		self.name = name
-		self.itselftype = itselftype
-		self.objecttype = name + 'Object'
-		self.typename = name + '_Type'
-		self.argref = ""	# set to "*" if arg to <type>_New should be pointer
-		self.static = "static " # set to "" to make <type>_New and <type>_Convert public
-		self.modulename = None
-		if hasattr(self, "assertions"):
-			self.assertions()
+    def __init__(self, name, prefix, itselftype):
+        """ObjectDefinition constructor.  May be extended, but do not override.
+        
+        - name: the object's official name, e.g. 'SndChannel'.
+        - prefix: the prefix used for the object's functions and data, e.g. 'SndCh'.
+        - itselftype: the C type actually contained in the object, e.g. 'SndChannelPtr'.
+        
+        XXX For official Python data types, rules for the 'Py' prefix are a problem.
+        """
+        
+        GeneratorGroup.__init__(self, prefix or name)
+        self.name = name
+        self.itselftype = itselftype
+        self.objecttype = name + 'Object'
+        self.typename = name + '_Type'
+        self.argref = ""    # set to "*" if arg to <type>_New should be pointer
+        self.static = "static " # set to "" to make <type>_New and <type>_Convert public
+        self.modulename = None
+        if hasattr(self, "assertions"):
+            self.assertions()
 
-	def add(self, g, dupcheck=0):
-		g.setselftype(self.objecttype, self.itselftype)
-		GeneratorGroup.add(self, g, dupcheck)
+    def add(self, g, dupcheck=0):
+        g.setselftype(self.objecttype, self.itselftype)
+        GeneratorGroup.add(self, g, dupcheck)
 
-	def reference(self):
-		# In case we are referenced from a module
-		pass
-		
-	def setmodulename(self, name):
-		self.modulename = name
+    def reference(self):
+        # In case we are referenced from a module
+        pass
+        
+    def setmodulename(self, name):
+        self.modulename = name
 
-	def generate(self):
-		# XXX This should use long strings and %(varname)s substitution!
+    def generate(self):
+        # XXX This should use long strings and %(varname)s substitution!
 
-		OutHeader2("Object type " + self.name)
+        OutHeader2("Object type " + self.name)
 
-		sf = self.static and "static "
-		Output("%sPyTypeObject %s;", sf, self.typename)
-		Output()
-		Output("#define %s_Check(x) ((x)->ob_type == &%s || PyObject_TypeCheck((x), &%s))",
-		       self.prefix, self.typename, self.typename)
-		Output()
-		Output("typedef struct %s {", self.objecttype)
-		IndentLevel()
-		Output("PyObject_HEAD")
-		self.outputStructMembers()
-		DedentLevel()
-		Output("} %s;", self.objecttype)
+        sf = self.static and "static "
+        Output("%sPyTypeObject %s;", sf, self.typename)
+        Output()
+        Output("#define %s_Check(x) ((x)->ob_type == &%s || PyObject_TypeCheck((x), &%s))",
+               self.prefix, self.typename, self.typename)
+        Output()
+        Output("typedef struct %s {", self.objecttype)
+        IndentLevel()
+        Output("PyObject_HEAD")
+        self.outputStructMembers()
+        DedentLevel()
+        Output("} %s;", self.objecttype)
 
-		self.outputNew()
-		
-		self.outputConvert()
+        self.outputNew()
+        
+        self.outputConvert()
 
-		self.outputDealloc()
+        self.outputDealloc()
 
-		GeneratorGroup.generate(self)
+        GeneratorGroup.generate(self)
 
-		Output()
-		self.outputMethodChain()
+        Output()
+        self.outputMethodChain()
 
-		self.outputGetattr()
+        self.outputGetattr()
 
-		self.outputSetattr()
-		
-		self.outputCompare()
-		
-		self.outputRepr()
-		
-		self.outputHash()
-		
-		self.outputPEP253Hooks()
-		
-		self.outputTypeObject()
+        self.outputSetattr()
+        
+        self.outputCompare()
+        
+        self.outputRepr()
+        
+        self.outputHash()
+        
+        self.outputPEP253Hooks()
+        
+        self.outputTypeObject()
 
-		OutHeader2("End object type " + self.name)
-		
-	def outputMethodChain(self):
-		Output("%sPyMethodChain %s_chain = { %s_methods, %s };",
-		        self.static,    self.prefix, self.prefix, self.basechain)
+        OutHeader2("End object type " + self.name)
+        
+    def outputMethodChain(self):
+        Output("%sPyMethodChain %s_chain = { %s_methods, %s };",
+                self.static,    self.prefix, self.prefix, self.basechain)
 
-	def outputStructMembers(self):
-		Output("%s ob_itself;", self.itselftype)
+    def outputStructMembers(self):
+        Output("%s ob_itself;", self.itselftype)
 
-	def outputNew(self):
-		Output()
-		Output("%sPyObject *%s_New(%s %sitself)", self.static, self.prefix,
-				self.itselftype, self.argref)
-		OutLbrace()
-		Output("%s *it;", self.objecttype)
-		self.outputCheckNewArg()
-		Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
-		Output("if (it == NULL) return NULL;")
-		if self.basetype:
-			Output("/* XXXX Should we tp_init or tp_new our basetype? */")
-		self.outputInitStructMembers()
-		Output("return (PyObject *)it;")
-		OutRbrace()
+    def outputNew(self):
+        Output()
+        Output("%sPyObject *%s_New(%s %sitself)", self.static, self.prefix,
+                self.itselftype, self.argref)
+        OutLbrace()
+        Output("%s *it;", self.objecttype)
+        self.outputCheckNewArg()
+        Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
+        Output("if (it == NULL) return NULL;")
+        if self.basetype:
+            Output("/* XXXX Should we tp_init or tp_new our basetype? */")
+        self.outputInitStructMembers()
+        Output("return (PyObject *)it;")
+        OutRbrace()
 
-	def outputInitStructMembers(self):
-		Output("it->ob_itself = %sitself;", self.argref)
-	
-	def outputCheckNewArg(self):
-			"Override this method to apply additional checks/conversions"
-	
-	def outputConvert(self):
-		Output("%sint %s_Convert(PyObject *v, %s *p_itself)", self.static, self.prefix,
-				self.itselftype)
-		OutLbrace()
-		self.outputCheckConvertArg()
-		Output("if (!%s_Check(v))", self.prefix)
-		OutLbrace()
-		Output('PyErr_SetString(PyExc_TypeError, "%s required");', self.name)
-		Output("return 0;")
-		OutRbrace()
-		Output("*p_itself = ((%s *)v)->ob_itself;", self.objecttype)
-		Output("return 1;")
-		OutRbrace()
+    def outputInitStructMembers(self):
+        Output("it->ob_itself = %sitself;", self.argref)
+    
+    def outputCheckNewArg(self):
+            "Override this method to apply additional checks/conversions"
+    
+    def outputConvert(self):
+        Output("%sint %s_Convert(PyObject *v, %s *p_itself)", self.static, self.prefix,
+                self.itselftype)
+        OutLbrace()
+        self.outputCheckConvertArg()
+        Output("if (!%s_Check(v))", self.prefix)
+        OutLbrace()
+        Output('PyErr_SetString(PyExc_TypeError, "%s required");', self.name)
+        Output("return 0;")
+        OutRbrace()
+        Output("*p_itself = ((%s *)v)->ob_itself;", self.objecttype)
+        Output("return 1;")
+        OutRbrace()
 
-	def outputCheckConvertArg(self):
-		"Override this method to apply additional conversions"
+    def outputCheckConvertArg(self):
+        "Override this method to apply additional conversions"
 
-	def outputDealloc(self):
-		Output()
-		Output("static void %s_dealloc(%s *self)", self.prefix, self.objecttype)
-		OutLbrace()
-		self.outputCleanupStructMembers()
-		if self.basetype:
-			Output("%s.tp_dealloc(self)", self.basetype)
-		elif hasattr(self, 'output_tp_free'):
-			# This is a new-style object with tp_free slot
-			Output("self->ob_type->tp_free((PyObject *)self);")
-		else:
-			Output("PyObject_Free((PyObject *)self);")
-		OutRbrace()
+    def outputDealloc(self):
+        Output()
+        Output("static void %s_dealloc(%s *self)", self.prefix, self.objecttype)
+        OutLbrace()
+        self.outputCleanupStructMembers()
+        if self.basetype:
+            Output("%s.tp_dealloc(self)", self.basetype)
+        elif hasattr(self, 'output_tp_free'):
+            # This is a new-style object with tp_free slot
+            Output("self->ob_type->tp_free((PyObject *)self);")
+        else:
+            Output("PyObject_Free((PyObject *)self);")
+        OutRbrace()
 
-	def outputCleanupStructMembers(self):
-		self.outputFreeIt("self->ob_itself")
+    def outputCleanupStructMembers(self):
+        self.outputFreeIt("self->ob_itself")
 
-	def outputFreeIt(self, name):
-		Output("/* Cleanup of %s goes here */", name)
+    def outputFreeIt(self, name):
+        Output("/* Cleanup of %s goes here */", name)
 
-	def outputGetattr(self):
-		Output()
-		Output("static PyObject *%s_getattr(%s *self, char *name)", self.prefix, self.objecttype)
-		OutLbrace()
-		self.outputGetattrBody()
-		OutRbrace()
+    def outputGetattr(self):
+        Output()
+        Output("static PyObject *%s_getattr(%s *self, char *name)", self.prefix, self.objecttype)
+        OutLbrace()
+        self.outputGetattrBody()
+        OutRbrace()
 
-	def outputGetattrBody(self):
-		self.outputGetattrHook()
-		Output("return Py_FindMethodInChain(&%s_chain, (PyObject *)self, name);",
-		       self.prefix)
+    def outputGetattrBody(self):
+        self.outputGetattrHook()
+        Output("return Py_FindMethodInChain(&%s_chain, (PyObject *)self, name);",
+               self.prefix)
 
-	def outputGetattrHook(self):
-		pass
+    def outputGetattrHook(self):
+        pass
 
-	def outputSetattr(self):
-		Output()
-		Output("#define %s_setattr NULL", self.prefix)
+    def outputSetattr(self):
+        Output()
+        Output("#define %s_setattr NULL", self.prefix)
 
-	def outputCompare(self):
-		Output()
-		Output("#define %s_compare NULL", self.prefix)
+    def outputCompare(self):
+        Output()
+        Output("#define %s_compare NULL", self.prefix)
 
-	def outputRepr(self):
-		Output()
-		Output("#define %s_repr NULL", self.prefix)
+    def outputRepr(self):
+        Output()
+        Output("#define %s_repr NULL", self.prefix)
 
-	def outputHash(self):
-		Output()
-		Output("#define %s_hash NULL", self.prefix)
+    def outputHash(self):
+        Output()
+        Output("#define %s_hash NULL", self.prefix)
 
-	def outputTypeObject(self):
-		sf = self.static and "static "
-		Output()
-		Output("%sPyTypeObject %s = {", sf, self.typename)
-		IndentLevel()
-		Output("PyObject_HEAD_INIT(NULL)")
-		Output("0, /*ob_size*/")
-		if self.modulename:
-			Output("\"%s.%s\", /*tp_name*/", self.modulename, self.name)
-		else:
-			Output("\"%s\", /*tp_name*/", self.name)
-		Output("sizeof(%s), /*tp_basicsize*/", self.objecttype)
-		Output("0, /*tp_itemsize*/")
-		Output("/* methods */")
-		Output("(destructor) %s_dealloc, /*tp_dealloc*/", self.prefix)
-		Output("0, /*tp_print*/")
-		Output("(getattrfunc) %s_getattr, /*tp_getattr*/", self.prefix)
-		Output("(setattrfunc) %s_setattr, /*tp_setattr*/", self.prefix)
-		Output("(cmpfunc) %s_compare, /*tp_compare*/", self.prefix)
-		Output("(reprfunc) %s_repr, /*tp_repr*/", self.prefix)
-		Output("(PyNumberMethods *)0, /* tp_as_number */")
-		Output("(PySequenceMethods *)0, /* tp_as_sequence */")
-		Output("(PyMappingMethods *)0, /* tp_as_mapping */")
-		Output("(hashfunc) %s_hash, /*tp_hash*/", self.prefix)
-		DedentLevel()
-		Output("};")
-		
-	def outputTypeObjectInitializer(self):
-		Output("""%s.ob_type = &PyType_Type;""", self.typename)
-		if self.basetype:
-			Output("%s.tp_base = %s;", self.typename, self.basetype)
-		Output("if (PyType_Ready(&%s) < 0) return;", self.typename)
-		Output("""Py_INCREF(&%s);""", self.typename)
-		Output("PyModule_AddObject(m, \"%s\", (PyObject *)&%s);", self.name, self.typename);
-		Output("/* Backward-compatible name */")
-		Output("""Py_INCREF(&%s);""", self.typename);
-		Output("PyModule_AddObject(m, \"%sType\", (PyObject *)&%s);", self.name, self.typename);
+    def outputTypeObject(self):
+        sf = self.static and "static "
+        Output()
+        Output("%sPyTypeObject %s = {", sf, self.typename)
+        IndentLevel()
+        Output("PyObject_HEAD_INIT(NULL)")
+        Output("0, /*ob_size*/")
+        if self.modulename:
+            Output("\"%s.%s\", /*tp_name*/", self.modulename, self.name)
+        else:
+            Output("\"%s\", /*tp_name*/", self.name)
+        Output("sizeof(%s), /*tp_basicsize*/", self.objecttype)
+        Output("0, /*tp_itemsize*/")
+        Output("/* methods */")
+        Output("(destructor) %s_dealloc, /*tp_dealloc*/", self.prefix)
+        Output("0, /*tp_print*/")
+        Output("(getattrfunc) %s_getattr, /*tp_getattr*/", self.prefix)
+        Output("(setattrfunc) %s_setattr, /*tp_setattr*/", self.prefix)
+        Output("(cmpfunc) %s_compare, /*tp_compare*/", self.prefix)
+        Output("(reprfunc) %s_repr, /*tp_repr*/", self.prefix)
+        Output("(PyNumberMethods *)0, /* tp_as_number */")
+        Output("(PySequenceMethods *)0, /* tp_as_sequence */")
+        Output("(PyMappingMethods *)0, /* tp_as_mapping */")
+        Output("(hashfunc) %s_hash, /*tp_hash*/", self.prefix)
+        DedentLevel()
+        Output("};")
+        
+    def outputTypeObjectInitializer(self):
+        Output("""%s.ob_type = &PyType_Type;""", self.typename)
+        if self.basetype:
+            Output("%s.tp_base = %s;", self.typename, self.basetype)
+        Output("if (PyType_Ready(&%s) < 0) return;", self.typename)
+        Output("""Py_INCREF(&%s);""", self.typename)
+        Output("PyModule_AddObject(m, \"%s\", (PyObject *)&%s);", self.name, self.typename);
+        Output("/* Backward-compatible name */")
+        Output("""Py_INCREF(&%s);""", self.typename);
+        Output("PyModule_AddObject(m, \"%sType\", (PyObject *)&%s);", self.name, self.typename);
 
-	def outputPEP253Hooks(self):
-		pass
-		
+    def outputPEP253Hooks(self):
+        pass
+        
 class PEP252Mixin:
-	getsetlist = []
-	
-	def assertions(self):
-		# Check that various things aren't overridden. If they are it could
-		# signify a bgen-client that has been partially converted to PEP252.
-		assert self.outputGetattr.im_func == PEP252Mixin.outputGetattr.im_func
-		assert self.outputSetattr.im_func == PEP252Mixin.outputSetattr.im_func
-		assert self.outputGetattrBody == None
-		assert self.outputGetattrHook == None
-		assert self.basechain == "NULL"
-		
-	def outputGetattr(self):
-		pass
-		
-	outputGetattrBody = None
+    getsetlist = []
+    
+    def assertions(self):
+        # Check that various things aren't overridden. If they are it could
+        # signify a bgen-client that has been partially converted to PEP252.
+        assert self.outputGetattr.im_func == PEP252Mixin.outputGetattr.im_func
+        assert self.outputSetattr.im_func == PEP252Mixin.outputSetattr.im_func
+        assert self.outputGetattrBody == None
+        assert self.outputGetattrHook == None
+        assert self.basechain == "NULL"
+        
+    def outputGetattr(self):
+        pass
+        
+    outputGetattrBody = None
 
-	outputGetattrHook = None
+    outputGetattrHook = None
 
-	def outputSetattr(self):
-		pass
-	
-	def outputMethodChain(self):
-		# This is a good place to output the getters and setters
-		self.outputGetSetList()
-	
-	def outputHook(self, name):
-		methodname = "outputHook_" + name
-		if hasattr(self, methodname):
-			func = getattr(self, methodname)
-			func()
-		else:
-			Output("0, /*%s*/", name)
-	
-	def outputTypeObject(self):
-		sf = self.static and "static "
-		Output()
-		Output("%sPyTypeObject %s = {", sf, self.typename)
-		IndentLevel()
-		Output("PyObject_HEAD_INIT(NULL)")
-		Output("0, /*ob_size*/")
-		if self.modulename:
-			Output("\"%s.%s\", /*tp_name*/", self.modulename, self.name)
-		else:
-			Output("\"%s\", /*tp_name*/", self.name)
-		Output("sizeof(%s), /*tp_basicsize*/", self.objecttype)
-		Output("0, /*tp_itemsize*/")
-		
-		Output("/* methods */")
-		Output("(destructor) %s_dealloc, /*tp_dealloc*/", self.prefix)
-		Output("0, /*tp_print*/")
-		Output("(getattrfunc)0, /*tp_getattr*/")
-		Output("(setattrfunc)0, /*tp_setattr*/")
-		Output("(cmpfunc) %s_compare, /*tp_compare*/", self.prefix)
-		Output("(reprfunc) %s_repr, /*tp_repr*/", self.prefix)
-		
-		Output("(PyNumberMethods *)0, /* tp_as_number */")
-		Output("(PySequenceMethods *)0, /* tp_as_sequence */")
-		Output("(PyMappingMethods *)0, /* tp_as_mapping */")
-		
-		Output("(hashfunc) %s_hash, /*tp_hash*/", self.prefix)
-		self.outputHook("tp_call")
-		Output("0, /*tp_str*/")
-		Output("PyObject_GenericGetAttr, /*tp_getattro*/")
-		Output("PyObject_GenericSetAttr, /*tp_setattro */")
-		
-		self.outputHook("tp_as_buffer")
-		Output("%s, /* tp_flags */", self.tp_flags)
-		self.outputHook("tp_doc")
-		self.outputHook("tp_traverse")
-		self.outputHook("tp_clear")
-		self.outputHook("tp_richcompare")
-		self.outputHook("tp_weaklistoffset")
-		self.outputHook("tp_iter")
-		self.outputHook("tp_iternext")
-		Output("%s_methods, /* tp_methods */", self.prefix)
-		self.outputHook("tp_members")
-		Output("%s_getsetlist, /*tp_getset*/", self.prefix)
-		self.outputHook("tp_base")
-		self.outputHook("tp_dict")
-		self.outputHook("tp_descr_get")
-		self.outputHook("tp_descr_set")
-		self.outputHook("tp_dictoffset")
-		self.outputHook("tp_init")
-		self.outputHook("tp_alloc")
-		self.outputHook("tp_new")
-		self.outputHook("tp_free")
-		DedentLevel()
-		Output("};")
-		
-	def outputGetSetList(self):
-		if self.getsetlist:
-			for name, get, set, doc in self.getsetlist:
-				if get:
-					self.outputGetter(name, get)
-				else:
-					Output("#define %s_get_%s NULL", self.prefix, name)
-					Output()
-				if set:
-					self.outputSetter(name, set)
-				else:
-					Output("#define %s_set_%s NULL", self.prefix, name)
-					Output()
-					
-			Output("static PyGetSetDef %s_getsetlist[] = {", self.prefix)
-			IndentLevel()
-			for name, get, set, doc in self.getsetlist:
-				if doc:
-					doc = '"' + doc + '"'
-				else:
-					doc = "NULL"
-				Output("{\"%s\", (getter)%s_get_%s, (setter)%s_set_%s, %s},", 
-					name, self.prefix, name, self.prefix, name, doc)
-			Output("{NULL, NULL, NULL, NULL},")
-			DedentLevel()
-			Output("};")
-		else:
-			Output("#define %s_getsetlist NULL", self.prefix)
-		Output()
-			
-	def outputGetter(self, name, code):
-		Output("static PyObject *%s_get_%s(%s *self, void *closure)",
-			self.prefix, name, self.objecttype)
-		OutLbrace()
-		Output(code)
-		OutRbrace()
-		Output()
-		
-	def outputSetter(self, name, code):
-		Output("static int %s_set_%s(%s *self, PyObject *v, void *closure)",
-			self.prefix, name, self.objecttype)
-		OutLbrace()
-		Output(code)
-		Output("return 0;")
-		OutRbrace()
-		Output()
-		
+    def outputSetattr(self):
+        pass
+    
+    def outputMethodChain(self):
+        # This is a good place to output the getters and setters
+        self.outputGetSetList()
+    
+    def outputHook(self, name):
+        methodname = "outputHook_" + name
+        if hasattr(self, methodname):
+            func = getattr(self, methodname)
+            func()
+        else:
+            Output("0, /*%s*/", name)
+    
+    def outputTypeObject(self):
+        sf = self.static and "static "
+        Output()
+        Output("%sPyTypeObject %s = {", sf, self.typename)
+        IndentLevel()
+        Output("PyObject_HEAD_INIT(NULL)")
+        Output("0, /*ob_size*/")
+        if self.modulename:
+            Output("\"%s.%s\", /*tp_name*/", self.modulename, self.name)
+        else:
+            Output("\"%s\", /*tp_name*/", self.name)
+        Output("sizeof(%s), /*tp_basicsize*/", self.objecttype)
+        Output("0, /*tp_itemsize*/")
+        
+        Output("/* methods */")
+        Output("(destructor) %s_dealloc, /*tp_dealloc*/", self.prefix)
+        Output("0, /*tp_print*/")
+        Output("(getattrfunc)0, /*tp_getattr*/")
+        Output("(setattrfunc)0, /*tp_setattr*/")
+        Output("(cmpfunc) %s_compare, /*tp_compare*/", self.prefix)
+        Output("(reprfunc) %s_repr, /*tp_repr*/", self.prefix)
+        
+        Output("(PyNumberMethods *)0, /* tp_as_number */")
+        Output("(PySequenceMethods *)0, /* tp_as_sequence */")
+        Output("(PyMappingMethods *)0, /* tp_as_mapping */")
+        
+        Output("(hashfunc) %s_hash, /*tp_hash*/", self.prefix)
+        self.outputHook("tp_call")
+        Output("0, /*tp_str*/")
+        Output("PyObject_GenericGetAttr, /*tp_getattro*/")
+        Output("PyObject_GenericSetAttr, /*tp_setattro */")
+        
+        self.outputHook("tp_as_buffer")
+        Output("%s, /* tp_flags */", self.tp_flags)
+        self.outputHook("tp_doc")
+        self.outputHook("tp_traverse")
+        self.outputHook("tp_clear")
+        self.outputHook("tp_richcompare")
+        self.outputHook("tp_weaklistoffset")
+        self.outputHook("tp_iter")
+        self.outputHook("tp_iternext")
+        Output("%s_methods, /* tp_methods */", self.prefix)
+        self.outputHook("tp_members")
+        Output("%s_getsetlist, /*tp_getset*/", self.prefix)
+        self.outputHook("tp_base")
+        self.outputHook("tp_dict")
+        self.outputHook("tp_descr_get")
+        self.outputHook("tp_descr_set")
+        self.outputHook("tp_dictoffset")
+        self.outputHook("tp_init")
+        self.outputHook("tp_alloc")
+        self.outputHook("tp_new")
+        self.outputHook("tp_free")
+        DedentLevel()
+        Output("};")
+        
+    def outputGetSetList(self):
+        if self.getsetlist:
+            for name, get, set, doc in self.getsetlist:
+                if get:
+                    self.outputGetter(name, get)
+                else:
+                    Output("#define %s_get_%s NULL", self.prefix, name)
+                    Output()
+                if set:
+                    self.outputSetter(name, set)
+                else:
+                    Output("#define %s_set_%s NULL", self.prefix, name)
+                    Output()
+                    
+            Output("static PyGetSetDef %s_getsetlist[] = {", self.prefix)
+            IndentLevel()
+            for name, get, set, doc in self.getsetlist:
+                if doc:
+                    doc = '"' + doc + '"'
+                else:
+                    doc = "NULL"
+                Output("{\"%s\", (getter)%s_get_%s, (setter)%s_set_%s, %s},", 
+                    name, self.prefix, name, self.prefix, name, doc)
+            Output("{NULL, NULL, NULL, NULL},")
+            DedentLevel()
+            Output("};")
+        else:
+            Output("#define %s_getsetlist NULL", self.prefix)
+        Output()
+            
+    def outputGetter(self, name, code):
+        Output("static PyObject *%s_get_%s(%s *self, void *closure)",
+            self.prefix, name, self.objecttype)
+        OutLbrace()
+        Output(code)
+        OutRbrace()
+        Output()
+        
+    def outputSetter(self, name, code):
+        Output("static int %s_set_%s(%s *self, PyObject *v, void *closure)",
+            self.prefix, name, self.objecttype)
+        OutLbrace()
+        Output(code)
+        Output("return 0;")
+        OutRbrace()
+        Output()
+        
 class PEP253Mixin(PEP252Mixin):
-	tp_flags = "Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE"
-	
-	def outputHook_tp_init(self):
-		Output("%s_tp_init, /* tp_init */", self.prefix)
-		
-	def outputHook_tp_alloc(self):
-		Output("%s_tp_alloc, /* tp_alloc */", self.prefix)
-	
-	def outputHook_tp_new(self):
-		Output("%s_tp_new, /* tp_new */", self.prefix)
-		
-	def outputHook_tp_free(self):
-		Output("%s_tp_free, /* tp_free */", self.prefix)
-		
-	output_tp_initBody = None
-	
-	def output_tp_init(self):
-		if self.output_tp_initBody:
-			Output("static int %s_tp_init(PyObject *self, PyObject *args, PyObject *kwds)", self.prefix)
-			OutLbrace()
-			self.output_tp_initBody()
-			OutRbrace()
-		else:
-			Output("#define %s_tp_init 0", self.prefix)
-		Output()
-		
-	output_tp_allocBody = None
-	
-	def output_tp_alloc(self):
-		if self.output_tp_allocBody:
-			Output("static PyObject *%s_tp_alloc(PyTypeObject *type, int nitems)",
-				self.prefix)
-			OutLbrace()
-			self.output_tp_allocBody()
-			OutRbrace()
-		else:
-			Output("#define %s_tp_alloc PyType_GenericAlloc", self.prefix)
-		Output()
-		
-	def output_tp_newBody(self):
-		Output("PyObject *self;");
-		Output("%s itself;", self.itselftype);
-		Output("char *kw[] = {\"itself\", 0};")
-		Output()
-		Output("if (!PyArg_ParseTupleAndKeywords(args, kwds, \"O&\", kw, %s_Convert, &itself)) return NULL;",
-			self.prefix);
-		Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
-		Output("((%s *)self)->ob_itself = itself;", self.objecttype)
-		Output("return self;")
-	
-	def output_tp_new(self):
-		if self.output_tp_newBody:
-			Output("static PyObject *%s_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)", self.prefix)
-			OutLbrace()
-			self.output_tp_newBody()
-			OutRbrace()
-		else:
-			Output("#define %s_tp_new PyType_GenericNew", self.prefix)
-		Output()
-	
-	output_tp_freeBody = None
-	
-	def output_tp_free(self):
-		if self.output_tp_freeBody:
-			Output("static void %s_tp_free(PyObject *self)", self.prefix)
-			OutLbrace()
-			self.output_tp_freeBody()
-			OutRbrace()
-		else:
-			Output("#define %s_tp_free PyObject_Del", self.prefix)
-		Output()
-		
-	def outputPEP253Hooks(self):
-		self.output_tp_init()
-		self.output_tp_alloc()
-		self.output_tp_new()
-		self.output_tp_free()
+    tp_flags = "Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE"
+    
+    def outputHook_tp_init(self):
+        Output("%s_tp_init, /* tp_init */", self.prefix)
+        
+    def outputHook_tp_alloc(self):
+        Output("%s_tp_alloc, /* tp_alloc */", self.prefix)
+    
+    def outputHook_tp_new(self):
+        Output("%s_tp_new, /* tp_new */", self.prefix)
+        
+    def outputHook_tp_free(self):
+        Output("%s_tp_free, /* tp_free */", self.prefix)
+        
+    output_tp_initBody = None
+    
+    def output_tp_init(self):
+        if self.output_tp_initBody:
+            Output("static int %s_tp_init(PyObject *self, PyObject *args, PyObject *kwds)", self.prefix)
+            OutLbrace()
+            self.output_tp_initBody()
+            OutRbrace()
+        else:
+            Output("#define %s_tp_init 0", self.prefix)
+        Output()
+        
+    output_tp_allocBody = None
+    
+    def output_tp_alloc(self):
+        if self.output_tp_allocBody:
+            Output("static PyObject *%s_tp_alloc(PyTypeObject *type, int nitems)",
+                self.prefix)
+            OutLbrace()
+            self.output_tp_allocBody()
+            OutRbrace()
+        else:
+            Output("#define %s_tp_alloc PyType_GenericAlloc", self.prefix)
+        Output()
+        
+    def output_tp_newBody(self):
+        Output("PyObject *self;");
+        Output("%s itself;", self.itselftype);
+        Output("char *kw[] = {\"itself\", 0};")
+        Output()
+        Output("if (!PyArg_ParseTupleAndKeywords(args, kwds, \"O&\", kw, %s_Convert, &itself)) return NULL;",
+            self.prefix);
+        Output("if ((self = type->tp_alloc(type, 0)) == NULL) return NULL;")
+        Output("((%s *)self)->ob_itself = itself;", self.objecttype)
+        Output("return self;")
+    
+    def output_tp_new(self):
+        if self.output_tp_newBody:
+            Output("static PyObject *%s_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)", self.prefix)
+            OutLbrace()
+            self.output_tp_newBody()
+            OutRbrace()
+        else:
+            Output("#define %s_tp_new PyType_GenericNew", self.prefix)
+        Output()
+    
+    output_tp_freeBody = None
+    
+    def output_tp_free(self):
+        if self.output_tp_freeBody:
+            Output("static void %s_tp_free(PyObject *self)", self.prefix)
+            OutLbrace()
+            self.output_tp_freeBody()
+            OutRbrace()
+        else:
+            Output("#define %s_tp_free PyObject_Del", self.prefix)
+        Output()
+        
+    def outputPEP253Hooks(self):
+        self.output_tp_init()
+        self.output_tp_alloc()
+        self.output_tp_new()
+        self.output_tp_free()
 
 class GlobalObjectDefinition(ObjectDefinition):
-	"""Like ObjectDefinition but exports some parts.
-	
-	XXX Should also somehow generate a .h file for them.
-	"""
+    """Like ObjectDefinition but exports some parts.
+    
+    XXX Should also somehow generate a .h file for them.
+    """
 
-	def __init__(self, name, prefix = None, itselftype = None):
-		ObjectDefinition.__init__(self, name, prefix or name, itselftype or name)
-		self.static = ""
+    def __init__(self, name, prefix = None, itselftype = None):
+        ObjectDefinition.__init__(self, name, prefix or name, itselftype or name)
+        self.static = ""
 
 class ObjectIdentityMixin:
-	"""A mixin class for objects that makes the identity of ob_itself
-	govern comparisons and dictionary lookups. Useful if the C object can
-	be returned by library calls and it is difficult (or impossible) to find
-	the corresponding Python objects. With this you can create Python object
-	wrappers on the fly"""
-	
-	def outputCompare(self):
-		Output()
-		Output("static int %s_compare(%s *self, %s *other)", self.prefix, self.objecttype,
-				self.objecttype)
-		OutLbrace()
-		Output("unsigned long v, w;")
-		Output()
-		Output("if (!%s_Check((PyObject *)other))", self.prefix)
-		OutLbrace()
-		Output("v=(unsigned long)self;")
-		Output("w=(unsigned long)other;")
-		OutRbrace()
-		Output("else")
-		OutLbrace()
-		Output("v=(unsigned long)self->ob_itself;")
-		Output("w=(unsigned long)other->ob_itself;")
-		OutRbrace()
-		Output("if( v < w ) return -1;")
-		Output("if( v > w ) return 1;")
-		Output("return 0;")
-		OutRbrace()
-		
-	def outputHash(self):
-		Output()
-		Output("static long %s_hash(%s *self)", self.prefix, self.objecttype)
-		OutLbrace()
-		Output("return (long)self->ob_itself;")
-		OutRbrace()
-		
+    """A mixin class for objects that makes the identity of ob_itself
+    govern comparisons and dictionary lookups. Useful if the C object can
+    be returned by library calls and it is difficult (or impossible) to find
+    the corresponding Python objects. With this you can create Python object
+    wrappers on the fly"""
+    
+    def outputCompare(self):
+        Output()
+        Output("static int %s_compare(%s *self, %s *other)", self.prefix, self.objecttype,
+                self.objecttype)
+        OutLbrace()
+        Output("unsigned long v, w;")
+        Output()
+        Output("if (!%s_Check((PyObject *)other))", self.prefix)
+        OutLbrace()
+        Output("v=(unsigned long)self;")
+        Output("w=(unsigned long)other;")
+        OutRbrace()
+        Output("else")
+        OutLbrace()
+        Output("v=(unsigned long)self->ob_itself;")
+        Output("w=(unsigned long)other->ob_itself;")
+        OutRbrace()
+        Output("if( v < w ) return -1;")
+        Output("if( v > w ) return 1;")
+        Output("return 0;")
+        OutRbrace()
+        
+    def outputHash(self):
+        Output()
+        Output("static long %s_hash(%s *self)", self.prefix, self.objecttype)
+        OutLbrace()
+        Output("return (long)self->ob_itself;")
+        OutRbrace()
+        
 
diff --git a/Tools/bgen/bgen/bgenOutput.py b/Tools/bgen/bgen/bgenOutput.py
index c7e560c..7ba5de3 100644
--- a/Tools/bgen/bgen/bgenOutput.py
+++ b/Tools/bgen/bgen/bgenOutput.py
@@ -9,211 +9,211 @@
 _NeedClose = 0
 
 def SetOutputFile(file = None, needclose = 0):
-	"""Call this with an open file object to make it the output file.
+    """Call this with an open file object to make it the output file.
 
-	Call it without arguments to close the current file (if necessary)
-	and reset it to sys.stdout.
-	If the second argument is true, the new file will be explicitly closed
-	on a subsequence call.
-	"""
-	global _File, _NeedClose
-	if _NeedClose:
-		tmp = _File
-		_NeedClose = 0
-		_File = None
-		tmp.close()
-	if file is None:
-		import sys
-		file = sys.stdout
-	_File = file
-	_NeedClose = file and needclose
+    Call it without arguments to close the current file (if necessary)
+    and reset it to sys.stdout.
+    If the second argument is true, the new file will be explicitly closed
+    on a subsequence call.
+    """
+    global _File, _NeedClose
+    if _NeedClose:
+        tmp = _File
+        _NeedClose = 0
+        _File = None
+        tmp.close()
+    if file is None:
+        import sys
+        file = sys.stdout
+    _File = file
+    _NeedClose = file and needclose
 
 def SetOutputFileName(filename = None):
-	"""Call this with a filename to make it the output file.
-	
-	Call it without arguments to close the current file (if necessary)
-	and reset it to sys.stdout.
-	"""
-	SetOutputFile()
-	if filename:
-		SetOutputFile(open(filename, 'w'), 1)
+    """Call this with a filename to make it the output file.
+    
+    Call it without arguments to close the current file (if necessary)
+    and reset it to sys.stdout.
+    """
+    SetOutputFile()
+    if filename:
+        SetOutputFile(open(filename, 'w'), 1)
 
-SetOutputFile()	# Initialize _File
+SetOutputFile() # Initialize _File
 
-_Level = 0		# Indentation level
+_Level = 0      # Indentation level
 
 def GetLevel():
-	"""Return the current indentation level."""
-	return _Level
+    """Return the current indentation level."""
+    return _Level
 
 def SetLevel(level):
-	"""Set the current indentation level.
+    """Set the current indentation level.
 
-	This does no type or range checking -- use at own risk.
-	"""
-	global _Level
-	_Level = level
+    This does no type or range checking -- use at own risk.
+    """
+    global _Level
+    _Level = level
 
 def Output(format = "", *args):
-	VaOutput(format, args)
+    VaOutput(format, args)
 
 def VaOutput(format, args):
-	"""Call this with a format string and and argument tuple for the format.
+    """Call this with a format string and and argument tuple for the format.
 
-	A newline is always added.  Each line in the output is indented
-	to the proper indentation level -- even if the result of the
-	format expansion contains embedded newlines.  Exception: lines
-	beginning with '#' are not indented -- these are assumed to be
-	C preprprocessor lines.
-	"""
-	text = format % args
-	if _Level > 0:
-		indent = '\t' * _Level
-		lines = text.split('\n')
-		for i in range(len(lines)):
-			if lines[i] and lines[i][0] != '#':
-				lines[i] = indent + lines[i]
-		text = '\n'.join(lines)
-	_File.write(text + '\n')
+    A newline is always added.  Each line in the output is indented
+    to the proper indentation level -- even if the result of the
+    format expansion contains embedded newlines.  Exception: lines
+    beginning with '#' are not indented -- these are assumed to be
+    C preprprocessor lines.
+    """
+    text = format % args
+    if _Level > 0:
+        indent = '\t' * _Level
+        lines = text.split('\n')
+        for i in range(len(lines)):
+            if lines[i] and lines[i][0] != '#':
+                lines[i] = indent + lines[i]
+        text = '\n'.join(lines)
+    _File.write(text + '\n')
 
 def IndentLevel(by = 1):
-	"""Increment the indentation level by one.
+    """Increment the indentation level by one.
 
-	When called with an argument, adds it to the indentation level.
-	"""
-	global _Level
-	if _Level+by < 0:
-		raise Error, "indentation underflow (internal error)"
-	_Level = _Level + by
+    When called with an argument, adds it to the indentation level.
+    """
+    global _Level
+    if _Level+by < 0:
+        raise Error, "indentation underflow (internal error)"
+    _Level = _Level + by
 
 def DedentLevel(by = 1):
-	"""Decrement the indentation level by one.
+    """Decrement the indentation level by one.
 
-	When called with an argument, subtracts it from the indentation level.
-	"""
-	IndentLevel(-by)
+    When called with an argument, subtracts it from the indentation level.
+    """
+    IndentLevel(-by)
 
 def OutIndent(format = "", *args):
-	"""Combine Output() followed by IndentLevel().
-	
-	If no text is given, acts like lone IndentLevel().
-	"""
-	if format: VaOutput(format, args)
-	IndentLevel()
+    """Combine Output() followed by IndentLevel().
+    
+    If no text is given, acts like lone IndentLevel().
+    """
+    if format: VaOutput(format, args)
+    IndentLevel()
 
 def OutDedent(format = "", *args):
-	"""Combine Output() followed by DedentLevel().
-	
-	If no text is given, acts like loneDedentLevel().
-	"""
-	if format: VaOutput(format, args)
-	DedentLevel()
+    """Combine Output() followed by DedentLevel().
+    
+    If no text is given, acts like loneDedentLevel().
+    """
+    if format: VaOutput(format, args)
+    DedentLevel()
 
 def OutLbrace(format = "", *args):
-	"""Like Output, but add a '{' and increase the indentation level.
-	
-	If no text is given a lone '{' is output.
-	"""
-	if format:
-		format = format + " {"
-	else:
-		format = "{"
-	VaOutput(format, args)
-	IndentLevel()
+    """Like Output, but add a '{' and increase the indentation level.
+    
+    If no text is given a lone '{' is output.
+    """
+    if format:
+        format = format + " {"
+    else:
+        format = "{"
+    VaOutput(format, args)
+    IndentLevel()
 
 def OutRbrace():
-	"""Decrease the indentation level and output a '}' on a line by itself."""
-	DedentLevel()
-	Output("}")
+    """Decrease the indentation level and output a '}' on a line by itself."""
+    DedentLevel()
+    Output("}")
 
 def OutHeader(text, dash):
-	"""Output a header comment using a given dash character."""
-	n = 64 - len(text)
-	Output()
-	Output("/* %s %s %s */", dash * (n/2), text, dash * (n - n/2))
-	Output()
+    """Output a header comment using a given dash character."""
+    n = 64 - len(text)
+    Output()
+    Output("/* %s %s %s */", dash * (n/2), text, dash * (n - n/2))
+    Output()
 
 def OutHeader1(text):
-	"""Output a level 1 header comment (uses '=' dashes)."""
-	OutHeader(text, "=")
+    """Output a level 1 header comment (uses '=' dashes)."""
+    OutHeader(text, "=")
 
 def OutHeader2(text):
-	"""Output a level 2 header comment (uses '-' dashes)."""
-	OutHeader(text, "-")
+    """Output a level 2 header comment (uses '-' dashes)."""
+    OutHeader(text, "-")
 
 def Out(text):
-	"""Output multiline text that's internally indented.
-	
-	Pass this a multiline character string.  The whitespace before the
-	first nonblank line of the string will be subtracted from all lines.
-	The lines are then output using Output(), but without interpretation
-	of formatting (if you need formatting you can do it before the call).
-	Recommended use:
-	
-		Out('''
-			int main(argc, argv)
-				int argc;
-				char *argv;
-			{
-				printf("Hello, world\\n");
-				exit(0);
-			}
-		''')
-	
-	Caveat: the indentation must be consistent -- if you use three tabs
-	in the first line, (up to) three tabs are removed from following lines,
-	but a line beginning with 24 spaces is not trimmed at all.  Don't use
-	this as a feature.
-	"""
-	# (Don't you love using triple quotes *inside* triple quotes? :-)
-	
-	lines = text.split('\n')
-	indent = ""
-	for line in lines:
-		if line.strip():
-			for c in line:
-				if not c.isspace():
-					break
-				indent = indent + c
-			break
-	n = len(indent)
-	for line in lines:
-		if line[:n] == indent:
-			line = line[n:]
-		else:
-			for c in indent:
-				if line[:1] <> c: break
-				line = line[1:]
-		VaOutput("%s", line)
+    """Output multiline text that's internally indented.
+    
+    Pass this a multiline character string.  The whitespace before the
+    first nonblank line of the string will be subtracted from all lines.
+    The lines are then output using Output(), but without interpretation
+    of formatting (if you need formatting you can do it before the call).
+    Recommended use:
+    
+        Out('''
+            int main(argc, argv)
+                int argc;
+                char *argv;
+            {
+                printf("Hello, world\\n");
+                exit(0);
+            }
+        ''')
+    
+    Caveat: the indentation must be consistent -- if you use three tabs
+    in the first line, (up to) three tabs are removed from following lines,
+    but a line beginning with 24 spaces is not trimmed at all.  Don't use
+    this as a feature.
+    """
+    # (Don't you love using triple quotes *inside* triple quotes? :-)
+    
+    lines = text.split('\n')
+    indent = ""
+    for line in lines:
+        if line.strip():
+            for c in line:
+                if not c.isspace():
+                    break
+                indent = indent + c
+            break
+    n = len(indent)
+    for line in lines:
+        if line[:n] == indent:
+            line = line[n:]
+        else:
+            for c in indent:
+                if line[:1] <> c: break
+                line = line[1:]
+        VaOutput("%s", line)
 
 
 def _test():
-	"""Test program.  Run when the module is run as a script."""
-	OutHeader1("test bgenOutput")
-	Out("""
-		#include <Python.h>
-		#include <stdio.h>
-	
-		main(argc, argv)
-			int argc;
-			char **argv;
-		{
-			int i;
-	""")
-	IndentLevel()
-	Output("""\
+    """Test program.  Run when the module is run as a script."""
+    OutHeader1("test bgenOutput")
+    Out("""
+        #include <Python.h>
+        #include <stdio.h>
+    
+        main(argc, argv)
+            int argc;
+            char **argv;
+        {
+            int i;
+    """)
+    IndentLevel()
+    Output("""\
 /* Here are a few comment lines.
    Just to test indenting multiple lines.
 
    End of the comment lines. */
 """)
-	Output("for (i = 0; i < argc; i++)")
-	OutLbrace()
-	Output('printf("argv[%%d] = %%s\\n", i, argv[i]);')
-	OutRbrace()
-	Output("exit(0)")
-	OutRbrace()
-	OutHeader2("end test")
+    Output("for (i = 0; i < argc; i++)")
+    OutLbrace()
+    Output('printf("argv[%%d] = %%s\\n", i, argv[i]);')
+    OutRbrace()
+    Output("exit(0)")
+    OutRbrace()
+    OutHeader2("end test")
 
 if __name__ == '__main__':
-	_test()
+    _test()
diff --git a/Tools/bgen/bgen/bgenStackBuffer.py b/Tools/bgen/bgen/bgenStackBuffer.py
index 1b6350a..9669607 100644
--- a/Tools/bgen/bgen/bgenStackBuffer.py
+++ b/Tools/bgen/bgen/bgenStackBuffer.py
@@ -6,54 +6,54 @@
 
 class StackOutputBufferType(FixedOutputBufferType):
 
-	"""Fixed output buffer allocated on the stack -- passed as (buffer, size).
+    """Fixed output buffer allocated on the stack -- passed as (buffer, size).
 
-	Instantiate with the buffer size as parameter.
-	"""
+    Instantiate with the buffer size as parameter.
+    """
 
-	def passOutput(self, name):
-		return "%s__out__, %s" % (name, self.size)
+    def passOutput(self, name):
+        return "%s__out__, %s" % (name, self.size)
 
 
 class VarStackOutputBufferType(StackOutputBufferType):
 
-	"""Output buffer allocated on the stack -- passed as (buffer, &size).
+    """Output buffer allocated on the stack -- passed as (buffer, &size).
 
-	Instantiate with the buffer size as parameter.
-	"""
+    Instantiate with the buffer size as parameter.
+    """
 
-	def declareSize(self, name):
-		Output("int %s__len__ = %s;", name, self.size)
+    def declareSize(self, name):
+        Output("int %s__len__ = %s;", name, self.size)
 
-	def passOutput(self, name):
-		return "%s__out__, &%s__len__" % (name, name)
+    def passOutput(self, name):
+        return "%s__out__, &%s__len__" % (name, name)
 
-	def mkvalueArgs(self, name):
-		return "%s__out__, (int)%s__len__" % (name, name)
+    def mkvalueArgs(self, name):
+        return "%s__out__, (int)%s__len__" % (name, name)
 
 
 class VarVarStackOutputBufferType(VarStackOutputBufferType):
 
-	"""Output buffer allocated on the stack -- passed as (buffer, size, &size).
+    """Output buffer allocated on the stack -- passed as (buffer, size, &size).
 
-	Instantiate with the buffer size as parameter.
-	"""
+    Instantiate with the buffer size as parameter.
+    """
 
-	def passOutput(self, name):
-		return "%s__out__, %s__len__, &%s__len__" % (name, name, name)
+    def passOutput(self, name):
+        return "%s__out__, %s__len__, &%s__len__" % (name, name, name)
 
 
 class ReturnVarStackOutputBufferType(VarStackOutputBufferType):
 
-	"""Output buffer allocated on the stack -- passed as (buffer, size) -> size.
+    """Output buffer allocated on the stack -- passed as (buffer, size) -> size.
 
-	Instantiate with the buffer size as parameter.
-	The function's return value is the size.
-	(XXX Should have a way to suppress returning it separately, too.)
-	"""
+    Instantiate with the buffer size as parameter.
+    The function's return value is the size.
+    (XXX Should have a way to suppress returning it separately, too.)
+    """
 
-	def passOutput(self, name):
-		return "%s__out__, %s__len__" % (name, name)
+    def passOutput(self, name):
+        return "%s__out__, %s__len__" % (name, name)
 
-	def mkvalueArgs(self, name):
-		return "%s__out__, (int)_rv" % name
+    def mkvalueArgs(self, name):
+        return "%s__out__, (int)_rv" % name
diff --git a/Tools/bgen/bgen/bgenStringBuffer.py b/Tools/bgen/bgen/bgenStringBuffer.py
index 7d9c77e..39c8cf9 100644
--- a/Tools/bgen/bgen/bgenStringBuffer.py
+++ b/Tools/bgen/bgen/bgenStringBuffer.py
@@ -8,57 +8,57 @@
 
 class StringBufferMixIn:
 
-	"""Mix-in class to create various string buffer types.
+    """Mix-in class to create various string buffer types.
 
-	Strings are character arrays terminated by a null byte.
-	(For input, this is also covered by stringptr.)
-	For output, there are again three variants:
-	- Fixed: size is a constant given in the documentation; or
-	- Stack: size is passed to the C function but we decide on a size at
-	  code generation time so we can still allocate on the heap); or
-	- Heap: size is passed to the C function and we let the Python caller
-	  pass a size.
-	(Note that this doesn't cover output parameters in which a string
-	pointer is returned.  These are actually easier (no allocation) but far
-	less common.  I'll write the classes when there is demand.)
-	"""
-	
-	def declareSize(self, name):
-		pass
-	
-	def getargsFormat(self):
-		return "s"
-	
-	def getargsArgs(self, name):
-		return "&%s__in__" % name
+    Strings are character arrays terminated by a null byte.
+    (For input, this is also covered by stringptr.)
+    For output, there are again three variants:
+    - Fixed: size is a constant given in the documentation; or
+    - Stack: size is passed to the C function but we decide on a size at
+      code generation time so we can still allocate on the heap); or
+    - Heap: size is passed to the C function and we let the Python caller
+      pass a size.
+    (Note that this doesn't cover output parameters in which a string
+    pointer is returned.  These are actually easier (no allocation) but far
+    less common.  I'll write the classes when there is demand.)
+    """
+    
+    def declareSize(self, name):
+        pass
+    
+    def getargsFormat(self):
+        return "s"
+    
+    def getargsArgs(self, name):
+        return "&%s__in__" % name
 
-	def mkvalueFormat(self):
-		return "s"
+    def mkvalueFormat(self):
+        return "s"
 
-	def mkvalueArgs(self, name):
-		return "%s__out__" % name
+    def mkvalueArgs(self, name):
+        return "%s__out__" % name
 
 
 class FixedOutputStringType(StringBufferMixIn, FixedOutputBufferType):
 
-	"""Null-terminated output string -- passed without size.
+    """Null-terminated output string -- passed without size.
 
-	Instantiate with buffer size as parameter.
-	"""
+    Instantiate with buffer size as parameter.
+    """
 
 
 class StackOutputStringType(StringBufferMixIn, StackOutputBufferType):
 
-	"""Null-terminated output string -- passed as (buffer, size).
+    """Null-terminated output string -- passed as (buffer, size).
 
-	Instantiate with buffer size as parameter.
-	"""
+    Instantiate with buffer size as parameter.
+    """
 
 
 class HeapOutputStringType(StringBufferMixIn, HeapOutputBufferType):
 
-	"""Null-terminated output string -- passed as (buffer, size).
+    """Null-terminated output string -- passed as (buffer, size).
 
-	Instantiate without parameters.
-	Call from Python with buffer size.
-	"""
+    Instantiate without parameters.
+    Call from Python with buffer size.
+    """
diff --git a/Tools/bgen/bgen/bgenType.py b/Tools/bgen/bgen/bgenType.py
index 51f5844..8ac3ac3 100644
--- a/Tools/bgen/bgen/bgenType.py
+++ b/Tools/bgen/bgen/bgenType.py
@@ -6,105 +6,105 @@
 
 class Type:
 
-	"""Define the various things you can do with a C type.
+    """Define the various things you can do with a C type.
 
-	Most methods are intended to be extended or overridden.
-	"""
+    Most methods are intended to be extended or overridden.
+    """
 
-	def __init__(self, typeName, fmt):
-		"""Call with the C name and getargs format for the type.
+    def __init__(self, typeName, fmt):
+        """Call with the C name and getargs format for the type.
 
-		Example: int = Type("int", "i")
-		"""
-		self.typeName = typeName
-		self.fmt = fmt
+        Example: int = Type("int", "i")
+        """
+        self.typeName = typeName
+        self.fmt = fmt
 
-	def declare(self, name):
-		"""Declare a variable of the type with a given name.
+    def declare(self, name):
+        """Declare a variable of the type with a given name.
 
-		Example: int.declare('spam') prints "int spam;"
-		"""
-		Output("%s %s;", self.typeName, name)
+        Example: int.declare('spam') prints "int spam;"
+        """
+        Output("%s %s;", self.typeName, name)
 
-	def getargs(self):
-		return self.getargsFormat(), self.getargsArgs()
+    def getargs(self):
+        return self.getargsFormat(), self.getargsArgs()
 
-	def getargsFormat(self):
-		"""Return the format for this type for use with [new]getargs().
+    def getargsFormat(self):
+        """Return the format for this type for use with [new]getargs().
 
-		Example: int.getargsFormat() returns the string "i".
-		"""
-		return self.fmt
+        Example: int.getargsFormat() returns the string "i".
+        """
+        return self.fmt
 
-	def getargsArgs(self, name):
-		"""Return an argument for use with [new]getargs().
+    def getargsArgs(self, name):
+        """Return an argument for use with [new]getargs().
 
-		Example: int.getargsArgs("spam") returns the string "&spam".
-		"""
-		return "&" + name
+        Example: int.getargsArgs("spam") returns the string "&spam".
+        """
+        return "&" + name
 
-	def getargsCheck(self, name):
-		"""Perform any needed post-[new]getargs() checks.
+    def getargsCheck(self, name):
+        """Perform any needed post-[new]getargs() checks.
 
-		This is type-dependent; the default does not check for errors.
-		An example would be a check for a maximum string length."""
+        This is type-dependent; the default does not check for errors.
+        An example would be a check for a maximum string length."""
 
-	def passInput(self, name):
-		"""Return an argument for passing a variable into a call.
+    def passInput(self, name):
+        """Return an argument for passing a variable into a call.
 
-		Example: int.passInput("spam") returns the string "spam".
-		"""
-		return name
+        Example: int.passInput("spam") returns the string "spam".
+        """
+        return name
 
-	def passOutput(self, name):
-		"""Return an argument for returning a variable out of a call.
+    def passOutput(self, name):
+        """Return an argument for returning a variable out of a call.
 
-		Example: int.passOutput("spam") returns the string "&spam".
-		"""
-		return "&" + name
+        Example: int.passOutput("spam") returns the string "&spam".
+        """
+        return "&" + name
 
-	def errorCheck(self, name):
-		"""Check for an error returned in the variable.
+    def errorCheck(self, name):
+        """Check for an error returned in the variable.
 
-		This is type-dependent; the default does not check for errors.
-		An example would be a check for a NULL pointer.
-		If an error is found, the generated routine should
-		raise an exception and return NULL.
+        This is type-dependent; the default does not check for errors.
+        An example would be a check for a NULL pointer.
+        If an error is found, the generated routine should
+        raise an exception and return NULL.
 
-		XXX There should be a way to add error clean-up code.
-		"""
-		Output("/* XXX no err check for %s %s */", self.typeName, name)
+        XXX There should be a way to add error clean-up code.
+        """
+        Output("/* XXX no err check for %s %s */", self.typeName, name)
 
-	def mkvalue(self):
-		return self.mkvalueFormat(), self.mkvalueArgs()
+    def mkvalue(self):
+        return self.mkvalueFormat(), self.mkvalueArgs()
 
-	def mkvalueFormat(self):
-		"""Return the format for this type for use with mkvalue().
+    def mkvalueFormat(self):
+        """Return the format for this type for use with mkvalue().
 
-		This is normally the same as getargsFormat() but it is
-		a separate function to allow future divergence.
-		"""
-		return self.getargsFormat()
+        This is normally the same as getargsFormat() but it is
+        a separate function to allow future divergence.
+        """
+        return self.getargsFormat()
 
-	def mkvalueArgs(self, name):
-		"""Return an argument for use with mkvalue().
+    def mkvalueArgs(self, name):
+        """Return an argument for use with mkvalue().
 
-		Example: int.mkvalueArgs("spam") returns the string "spam".
-		"""
-		return name
+        Example: int.mkvalueArgs("spam") returns the string "spam".
+        """
+        return name
 
-	def cleanup(self, name):
-		"""Clean up if necessary.
+    def cleanup(self, name):
+        """Clean up if necessary.
 
-		This is normally empty; it may deallocate buffers etc.
-		"""
-		pass
+        This is normally empty; it may deallocate buffers etc.
+        """
+        pass
 
 class ByAddressType(Type):
-	"Simple type that is also passed by address for input"
+    "Simple type that is also passed by address for input"
 
-	def passInput(self, name):
-		return "&%s" % name
+    def passInput(self, name):
+        return "&%s" % name
 
 
 
@@ -112,25 +112,25 @@
 
 class InputOnlyMixIn:
 
-	"Mix-in class to boobytrap passOutput"
+    "Mix-in class to boobytrap passOutput"
 
-	def passOutput(self, name):
-		raise RuntimeError, "Type '%s' can only be used for input parameters" % self.typeName
+    def passOutput(self, name):
+        raise RuntimeError, "Type '%s' can only be used for input parameters" % self.typeName
 
 class InputOnlyType(InputOnlyMixIn, Type):
 
-	"Same as Type, but only usable for input parameters -- passOutput is boobytrapped"
+    "Same as Type, but only usable for input parameters -- passOutput is boobytrapped"
 
 class OutputOnlyMixIn:
 
-	"Mix-in class to boobytrap passInput"
+    "Mix-in class to boobytrap passInput"
 
-	def passInput(self, name):
-		raise RuntimeError, "Type '%s' can only be used for output parameters" % self.typeName
+    def passInput(self, name):
+        raise RuntimeError, "Type '%s' can only be used for output parameters" % self.typeName
 
 class OutputOnlyType(OutputOnlyMixIn, Type):
 
-	"Same as Type, but only usable for output parameters -- passInput is boobytrapped"
+    "Same as Type, but only usable for output parameters -- passInput is boobytrapped"
 
 
 # A modest collection of standard C types.
@@ -160,99 +160,99 @@
 
 class FakeType(InputOnlyType):
 
-	"""A type that is not represented in the Python version of the interface.
+    """A type that is not represented in the Python version of the interface.
 
-	Instantiate with a value to pass in the call.
-	"""
+    Instantiate with a value to pass in the call.
+    """
 
-	def __init__(self, substitute):
-		self.substitute = substitute
-		self.typeName = None	# Don't show this argument in __doc__ string
+    def __init__(self, substitute):
+        self.substitute = substitute
+        self.typeName = None    # Don't show this argument in __doc__ string
 
-	def declare(self, name):
-		pass
+    def declare(self, name):
+        pass
 
-	def getargsFormat(self):
-		return ""
+    def getargsFormat(self):
+        return ""
 
-	def getargsArgs(self, name):
-		return None
+    def getargsArgs(self, name):
+        return None
 
-	def passInput(self, name):
-		return self.substitute
+    def passInput(self, name):
+        return self.substitute
 
 
 class OpaqueType(Type):
 
-	"""A type represented by an opaque object type, always passed by address.
+    """A type represented by an opaque object type, always passed by address.
 
-	Instantiate with the type name and the names of the new and convert procs.
-	If fewer than three arguments are passed, the second argument is used
-	to derive the new and convert procs by appending _New and _Convert; it
-	defaults to the first argument.
-	"""
+    Instantiate with the type name and the names of the new and convert procs.
+    If fewer than three arguments are passed, the second argument is used
+    to derive the new and convert procs by appending _New and _Convert; it
+    defaults to the first argument.
+    """
 
-	def __init__(self, name, arg = None, extra = None):
-		self.typeName = name
-		if extra is None:
-			 # Two arguments (name, usetype) or one (name)
-			arg = arg or name
-			self.new = arg + '_New'
-			self.convert = arg + '_Convert'
-		else:
-			# Three arguments (name, new, convert)
-			self.new = arg 
-			self.convert = extra 
+    def __init__(self, name, arg = None, extra = None):
+        self.typeName = name
+        if extra is None:
+             # Two arguments (name, usetype) or one (name)
+            arg = arg or name
+            self.new = arg + '_New'
+            self.convert = arg + '_Convert'
+        else:
+            # Three arguments (name, new, convert)
+            self.new = arg 
+            self.convert = extra 
 
-	def getargsFormat(self):
-		return "O&"
+    def getargsFormat(self):
+        return "O&"
 
-	def getargsArgs(self, name):
-		return "%s, &%s" % (self.convert, name)
+    def getargsArgs(self, name):
+        return "%s, &%s" % (self.convert, name)
 
-	def passInput(self, name):
-		return "&%s" % name
+    def passInput(self, name):
+        return "&%s" % name
 
-	def mkvalueFormat(self):
-		return "O&"
+    def mkvalueFormat(self):
+        return "O&"
 
-	def mkvalueArgs(self, name):
-		return "%s, &%s" % (self.new, name)
+    def mkvalueArgs(self, name):
+        return "%s, &%s" % (self.new, name)
 
 
 class OpaqueByValueType(OpaqueType):
 
-	"""A type represented by an opaque object type, on input passed BY VALUE.
+    """A type represented by an opaque object type, on input passed BY VALUE.
 
-	Instantiate with the type name, and optionally an object type name whose
-	New/Convert functions will be used.
-	"""
+    Instantiate with the type name, and optionally an object type name whose
+    New/Convert functions will be used.
+    """
 
-	def passInput(self, name):
-		return name
+    def passInput(self, name):
+        return name
 
-	def mkvalueArgs(self, name):
-		return "%s, %s" % (self.new, name)
-		
+    def mkvalueArgs(self, name):
+        return "%s, %s" % (self.new, name)
+        
 class OpaqueByValueStructType(OpaqueByValueType):
-	"""Similar to OpaqueByValueType, but we also pass this to mkvalue by
-	address, in stead of by value.
-	"""
+    """Similar to OpaqueByValueType, but we also pass this to mkvalue by
+    address, in stead of by value.
+    """
 
-	def mkvalueArgs(self, name):
-		return "%s, &%s" % (self.new, name)
+    def mkvalueArgs(self, name):
+        return "%s, &%s" % (self.new, name)
 
 
 class OpaqueArrayType(OpaqueByValueType):
 
-	"""A type represented by an opaque object type, with ARRAY passing semantics.
+    """A type represented by an opaque object type, with ARRAY passing semantics.
 
-	Instantiate with the type name, and optional an object type name whose
-	New/Convert functions will be used.
-	"""
+    Instantiate with the type name, and optional an object type name whose
+    New/Convert functions will be used.
+    """
 
-	def getargsArgs(self, name):
-		return "%s, %s" % (self.convert, name)
+    def getargsArgs(self, name):
+        return "%s, %s" % (self.convert, name)
 
-	def passOutput(self, name):
-		return name
+    def passOutput(self, name):
+        return name
diff --git a/Tools/bgen/bgen/bgenVariable.py b/Tools/bgen/bgen/bgenVariable.py
index 310cc8f..7b947ab 100644
--- a/Tools/bgen/bgen/bgenVariable.py
+++ b/Tools/bgen/bgen/bgenVariable.py
@@ -17,72 +17,72 @@
 
 class Variable:
 
-	"""A Variable holds a type, a name, a transfer mode and flags.
+    """A Variable holds a type, a name, a transfer mode and flags.
 
-	Most of its methods call the correponding type method with the
-	variable name.
-	"""
+    Most of its methods call the correponding type method with the
+    variable name.
+    """
 
-	def __init__(self, type, name = None, flags = InMode):
-		"""Call with a type, a name and flags.
+    def __init__(self, type, name = None, flags = InMode):
+        """Call with a type, a name and flags.
 
-		If name is None, it muse be set later.
-		flags defaults to InMode.
-		"""
-		self.type = type
-		self.name = name
-		self.flags = flags
-		self.mode = flags & ModeMask
+        If name is None, it muse be set later.
+        flags defaults to InMode.
+        """
+        self.type = type
+        self.name = name
+        self.flags = flags
+        self.mode = flags & ModeMask
 
-	def declare(self):
-		"""Declare the variable if necessary.
+    def declare(self):
+        """Declare the variable if necessary.
 
-		If it is "self", it is not declared.
-		"""
-		if self.flags != SelfMode:
-			self.type.declare(self.name)
+        If it is "self", it is not declared.
+        """
+        if self.flags != SelfMode:
+            self.type.declare(self.name)
 
-	def getargsFormat(self):
-		"""Call the type's getargsFormatmethod."""
-		return self.type.getargsFormat()
+    def getargsFormat(self):
+        """Call the type's getargsFormatmethod."""
+        return self.type.getargsFormat()
 
-	def getargsArgs(self):
-		"""Call the type's getargsArgsmethod."""
-		return self.type.getargsArgs(self.name)
+    def getargsArgs(self):
+        """Call the type's getargsArgsmethod."""
+        return self.type.getargsArgs(self.name)
 
-	def getargsCheck(self):
-		return self.type.getargsCheck(self.name)
+    def getargsCheck(self):
+        return self.type.getargsCheck(self.name)
 
-	def passArgument(self):
-		"""Return the string required to pass the variable as argument.
+    def passArgument(self):
+        """Return the string required to pass the variable as argument.
 
-		For "in" arguments, return the variable name.
-		For "out" and "in out" arguments,
-		return its name prefixed with "&".
-		"""
-		if self.mode == InMode:
-			return self.type.passInput(self.name)
-		if self.mode in (OutMode, InOutMode):
-			return self.type.passOutput(self.name)
-		# XXX Shouldn't get here
-		return "/*mode?*/" + self.type.passInput(self.name)
+        For "in" arguments, return the variable name.
+        For "out" and "in out" arguments,
+        return its name prefixed with "&".
+        """
+        if self.mode == InMode:
+            return self.type.passInput(self.name)
+        if self.mode in (OutMode, InOutMode):
+            return self.type.passOutput(self.name)
+        # XXX Shouldn't get here
+        return "/*mode?*/" + self.type.passInput(self.name)
 
-	def errorCheck(self):
-		"""Check for an error if necessary.
+    def errorCheck(self):
+        """Check for an error if necessary.
 
-		This only generates code if the variable's mode is ErrorMode.
-		"""
-		if self.flags == ErrorMode:
-			self.type.errorCheck(self.name)
+        This only generates code if the variable's mode is ErrorMode.
+        """
+        if self.flags == ErrorMode:
+            self.type.errorCheck(self.name)
 
-	def mkvalueFormat (self):
-		"""Call the type's mkvalueFormat method."""
-		return self.type.mkvalueFormat()
+    def mkvalueFormat (self):
+        """Call the type's mkvalueFormat method."""
+        return self.type.mkvalueFormat()
 
-	def mkvalueArgs(self):
-		"""Call the type's mkvalueArgs method."""
-		return self.type.mkvalueArgs(self.name)
+    def mkvalueArgs(self):
+        """Call the type's mkvalueArgs method."""
+        return self.type.mkvalueArgs(self.name)
 
-	def cleanup(self):
-		"""Call the type's cleanup method."""
-		return self.type.cleanup(self.name)
+    def cleanup(self):
+        """Call the type's cleanup method."""
+        return self.type.cleanup(self.name)
diff --git a/Tools/bgen/bgen/macsupport.py b/Tools/bgen/bgen/macsupport.py
index 049354a..b4885ad 100644
--- a/Tools/bgen/bgen/macsupport.py
+++ b/Tools/bgen/bgen/macsupport.py
@@ -52,7 +52,7 @@
 
 # OSType and ResType: 4-byte character strings
 def OSTypeType(typename):
-	return OpaqueByValueType(typename, "PyMac_BuildOSType", "PyMac_GetOSType")
+    return OpaqueByValueType(typename, "PyMac_BuildOSType", "PyMac_GetOSType")
 OSType = OSTypeType("OSType")
 ResType = OSTypeType("ResType")
 FourCharCode = OSTypeType("FourCharCode")
@@ -104,35 +104,35 @@
 # OSErr is special because it is turned into an exception
 # (Could do this with less code using a variant of mkvalue("O&")?)
 class OSErrType(Type):
-	def errorCheck(self, name):
-		Output("if (%s != noErr) return PyMac_Error(%s);", name, name)
-		self.used = 1
+    def errorCheck(self, name):
+        Output("if (%s != noErr) return PyMac_Error(%s);", name, name)
+        self.used = 1
 OSErr = OSErrType("OSErr", 'h')
 OSStatus = OSErrType("OSStatus", 'l')
 
 
 # Various buffer types
 
-InBuffer = VarInputBufferType('char', 'long', 'l')		# (buf, len)
-UcharInBuffer  = VarInputBufferType('unsigned char', 'long', 'l')		# (buf, len)
-OptionalInBuffer = OptionalVarInputBufferType('char', 'long', 'l')		# (buf, len)
+InBuffer = VarInputBufferType('char', 'long', 'l')      # (buf, len)
+UcharInBuffer  = VarInputBufferType('unsigned char', 'long', 'l')       # (buf, len)
+OptionalInBuffer = OptionalVarInputBufferType('char', 'long', 'l')      # (buf, len)
 
-InOutBuffer = HeapInputOutputBufferType('char', 'long', 'l')	# (inbuf, outbuf, len)
+InOutBuffer = HeapInputOutputBufferType('char', 'long', 'l')    # (inbuf, outbuf, len)
 VarInOutBuffer = VarHeapInputOutputBufferType('char', 'long', 'l') # (inbuf, outbuf, &len)
 
-OutBuffer = HeapOutputBufferType('char', 'long', 'l')		# (buf, len)
-VarOutBuffer = VarHeapOutputBufferType('char', 'long', 'l')	# (buf, &len)
+OutBuffer = HeapOutputBufferType('char', 'long', 'l')       # (buf, len)
+VarOutBuffer = VarHeapOutputBufferType('char', 'long', 'l') # (buf, &len)
 VarVarOutBuffer = VarVarHeapOutputBufferType('char', 'long', 'l') # (buf, len, &len)
 
 # Unicode arguments sometimes have reversed len, buffer (don't understand why Apple did this...)
 class VarUnicodeInputBufferType(VarInputBufferType):
 
-	def getargsFormat(self):
-		return "u#"
-		
+    def getargsFormat(self):
+        return "u#"
+        
 class VarUnicodeReverseInputBufferType(ReverseInputBufferMixin, VarUnicodeInputBufferType):
-	pass
-	
+    pass
+    
 UnicodeInBuffer = VarUnicodeInputBufferType('UniChar', 'UniCharCount', 'l')
 UnicodeReverseInBuffer = VarUnicodeReverseInputBufferType('UniChar', 'UniCharCount', 'l')
 UniChar_ptr = InputOnlyType("UniCharPtr", "u")
@@ -151,9 +151,9 @@
 
 /* Macro to test whether a weak-loaded CFM function exists */
 #define PyMac_PRECHECK(rtn) do { if ( &rtn == NULL )  {\\
-    	PyErr_SetString(PyExc_NotImplementedError, \\
-    	"Not available in this shared library/OS version"); \\
-    	return NULL; \\
+        PyErr_SetString(PyExc_NotImplementedError, \\
+        "Not available in this shared library/OS version"); \\
+        return NULL; \\
     }} while(0)
 
 """
@@ -173,23 +173,23 @@
 # This requires that the OSErr type (defined above) has a non-trivial
 # errorCheck method.
 class OSErrMixIn:
-	"Mix-in class to treat OSErr/OSStatus return values special"
-	def makereturnvar(self):
-		if self.returntype.__class__ == OSErrType:
-			return Variable(self.returntype, "_err", ErrorMode)
-		else:
-			return Variable(self.returntype, "_rv", OutMode)
+    "Mix-in class to treat OSErr/OSStatus return values special"
+    def makereturnvar(self):
+        if self.returntype.__class__ == OSErrType:
+            return Variable(self.returntype, "_err", ErrorMode)
+        else:
+            return Variable(self.returntype, "_rv", OutMode)
 
 class OSErrFunctionGenerator(OSErrMixIn, FunctionGenerator): pass
 class OSErrMethodGenerator(OSErrMixIn, MethodGenerator): pass
 
 class WeakLinkMixIn:
-	"Mix-in to test the function actually exists (!= NULL) before calling"
-	
-	def precheck(self):
-		Output('#ifndef %s', self.name)
-		Output('PyMac_PRECHECK(%s);', self.name)
-		Output('#endif')
+    "Mix-in to test the function actually exists (!= NULL) before calling"
+    
+    def precheck(self):
+        Output('#ifndef %s', self.name)
+        Output('PyMac_PRECHECK(%s);', self.name)
+        Output('#endif')
 
 class WeakLinkFunctionGenerator(WeakLinkMixIn, FunctionGenerator): pass
 class WeakLinkMethodGenerator(WeakLinkMixIn, MethodGenerator): pass
@@ -197,14 +197,14 @@
 class OSErrWeakLinkMethodGenerator(OSErrMixIn, WeakLinkMixIn, MethodGenerator): pass
 
 class MacModule(Module):
-	"Subclass which gets the exception initializer from macglue.c"
-	def exceptionInitializer(self):
-		return "PyMac_GetOSErrException()"
+    "Subclass which gets the exception initializer from macglue.c"
+    def exceptionInitializer(self):
+        return "PyMac_GetOSErrException()"
 
 _SetOutputFileName = SetOutputFileName # Save original
 def SetOutputFileName(file = None):
-	"Set the output file name and set its creator&type to CWIE&TEXT"
-	_SetOutputFileName(file)
-	if file:
-		import MacOS
-		MacOS.SetCreatorAndType(file, 'CWIE', 'TEXT')
+    "Set the output file name and set its creator&type to CWIE&TEXT"
+    _SetOutputFileName(file)
+    if file:
+        import MacOS
+        MacOS.SetCreatorAndType(file, 'CWIE', 'TEXT')
diff --git a/Tools/bgen/bgen/scantools.py b/Tools/bgen/bgen/scantools.py
index 61c2f37..b9b6854 100644
--- a/Tools/bgen/bgen/scantools.py
+++ b/Tools/bgen/bgen/scantools.py
@@ -20,650 +20,650 @@
 import fnmatch
 from types import *
 try:
-	import MacOS
+    import MacOS
 except ImportError:
-	MacOS = None
+    MacOS = None
 
 try:
-	from bgenlocations import CREATOR, INCLUDEDIR
+    from bgenlocations import CREATOR, INCLUDEDIR
 except ImportError:
-	CREATOR = None
-	INCLUDEDIR = os.curdir
+    CREATOR = None
+    INCLUDEDIR = os.curdir
 
 Error = "scantools.Error"
 
 class Scanner:
 
-	# Set to 1 in subclass to debug your scanner patterns.
-	debug = 0
+    # Set to 1 in subclass to debug your scanner patterns.
+    debug = 0
 
-	def __init__(self, input = None, output = None, defsoutput = None):
-		self.initsilent()
-		self.initblacklists()
-		self.initrepairinstructions()
-		self.initpaths()
-		self.initfiles()
-		self.initpatterns()
-		self.compilepatterns()
-		self.initosspecifics()
-		self.initusedtypes()
-		if output:
-			self.setoutput(output, defsoutput)
-		if input:
-			self.setinput(input)
-	
-	def initusedtypes(self):
-		self.usedtypes = {}
-	
-	def typeused(self, type, mode):
-		if not self.usedtypes.has_key(type):
-			self.usedtypes[type] = {}
-		self.usedtypes[type][mode] = None
-	
-	def reportusedtypes(self):
-		types = self.usedtypes.keys()
-		types.sort()
-		for type in types:
-			modes = self.usedtypes[type].keys()
-			modes.sort()
-			self.report("%s %s", type, " ".join(modes))
+    def __init__(self, input = None, output = None, defsoutput = None):
+        self.initsilent()
+        self.initblacklists()
+        self.initrepairinstructions()
+        self.initpaths()
+        self.initfiles()
+        self.initpatterns()
+        self.compilepatterns()
+        self.initosspecifics()
+        self.initusedtypes()
+        if output:
+            self.setoutput(output, defsoutput)
+        if input:
+            self.setinput(input)
+    
+    def initusedtypes(self):
+        self.usedtypes = {}
+    
+    def typeused(self, type, mode):
+        if not self.usedtypes.has_key(type):
+            self.usedtypes[type] = {}
+        self.usedtypes[type][mode] = None
+    
+    def reportusedtypes(self):
+        types = self.usedtypes.keys()
+        types.sort()
+        for type in types:
+            modes = self.usedtypes[type].keys()
+            modes.sort()
+            self.report("%s %s", type, " ".join(modes))
 
-	def gentypetest(self, file):
-		fp = open(file, "w")
-		fp.write("types=[\n")
-		types = self.usedtypes.keys()
-		types.sort()
-		for type in types:
-			fp.write("\t'%s',\n"%type)
-		fp.write("]\n")
-		fp.write("""missing=0
+    def gentypetest(self, file):
+        fp = open(file, "w")
+        fp.write("types=[\n")
+        types = self.usedtypes.keys()
+        types.sort()
+        for type in types:
+            fp.write("\t'%s',\n"%type)
+        fp.write("]\n")
+        fp.write("""missing=0
 for t in types:
-	try:
-		tt = eval(t)
-	except NameError:
-		print "** Missing type:", t
-		missing = 1
+    try:
+        tt = eval(t)
+    except NameError:
+        print "** Missing type:", t
+        missing = 1
 if missing: raise "Missing Types"
 """)
-		fp.close()
+        fp.close()
 
-	def initsilent(self):
-		self.silent = 1
+    def initsilent(self):
+        self.silent = 1
 
-	def error(self, format, *args):
-		if self.silent >= 0:
-			print format%args
+    def error(self, format, *args):
+        if self.silent >= 0:
+            print format%args
 
-	def report(self, format, *args):
-		if not self.silent:
-			print format%args
+    def report(self, format, *args):
+        if not self.silent:
+            print format%args
 
-	def writeinitialdefs(self):
-		pass
-		
-	def initblacklists(self):
-		self.blacklistnames = self.makeblacklistnames()
-		self.blacklisttypes = ["unknown", "-"] + self.makeblacklisttypes()
-		self.greydictnames = self.greylist2dict(self.makegreylist())
-		
-	def greylist2dict(self, list):
-		rv = {}
-		for define, namelist in list:
-			for name in namelist:
-				rv[name] = define
-		return rv
+    def writeinitialdefs(self):
+        pass
+        
+    def initblacklists(self):
+        self.blacklistnames = self.makeblacklistnames()
+        self.blacklisttypes = ["unknown", "-"] + self.makeblacklisttypes()
+        self.greydictnames = self.greylist2dict(self.makegreylist())
+        
+    def greylist2dict(self, list):
+        rv = {}
+        for define, namelist in list:
+            for name in namelist:
+                rv[name] = define
+        return rv
 
-	def makeblacklistnames(self):
-		return []
+    def makeblacklistnames(self):
+        return []
 
-	def makeblacklisttypes(self):
-		return []
-		
-	def makegreylist(self):
-		return []
+    def makeblacklisttypes(self):
+        return []
+        
+    def makegreylist(self):
+        return []
 
-	def initrepairinstructions(self):
-		self.repairinstructions = self.makerepairinstructions()
-		self.inherentpointertypes = self.makeinherentpointertypes()
+    def initrepairinstructions(self):
+        self.repairinstructions = self.makerepairinstructions()
+        self.inherentpointertypes = self.makeinherentpointertypes()
 
-	def makerepairinstructions(self):
-		"""Parse the repair file into repair instructions.
-		
-		The file format is simple:
-		1) use \ to split a long logical line in multiple physical lines
-		2) everything after the first # on a line is ignored (as comment)
-		3) empty lines are ignored
-		4) remaining lines must have exactly 3 colon-separated fields:
-		   functionpattern : argumentspattern : argumentsreplacement
-		5) all patterns use shell style pattern matching
-		6) an empty functionpattern means the same as *
-		7) the other two fields are each comma-separated lists of triples
-		8) a triple is a space-separated list of 1-3 words
-		9) a triple with less than 3 words is padded at the end with "*" words
-		10) when used as a pattern, a triple matches the type, name, and mode
-		    of an argument, respectively
-		11) when used as a replacement, the words of a triple specify
-		    replacements for the corresponding words of the argument,
-		    with "*" as a word by itself meaning leave the original word
-		    (no other uses of "*" is allowed)
-		12) the replacement need not have the same number of triples
-		    as the pattern
-		"""
-		f = self.openrepairfile()
-		if not f: return []
-		print "Reading repair file", `f.name`, "..."
-		list = []
-		lineno = 0
-		while 1:
-			line = f.readline()
-			if not line: break
-			lineno = lineno + 1
-			startlineno = lineno
-			while line[-2:] == '\\\n':
-				line = line[:-2] + ' ' + f.readline()
-				lineno = lineno + 1
-			i = line.find('#')
-			if i >= 0: line = line[:i]
-			words = [s.strip() for s in line.split(':')]
-			if words == ['']: continue
-			if len(words) <> 3:
-				print "Line", startlineno,
-				print ": bad line (not 3 colon-separated fields)"
-				print `line`
-				continue
-			[fpat, pat, rep] = words
-			if not fpat: fpat = "*"
-			if not pat:
-				print "Line", startlineno,
-				print "Empty pattern"
-				print `line`
-				continue
-			patparts = [s.strip() for s in pat.split(',')]
-			repparts = [s.strip() for s in rep.split(',')]
-			patterns = []
-			for p in patparts:
-				if not p:
-					print "Line", startlineno,
-					print "Empty pattern part"
-					print `line`
-					continue
-				pattern = p.split()
-				if len(pattern) > 3:
-					print "Line", startlineno,
-					print "Pattern part has > 3 words"
-					print `line`
-					pattern = pattern[:3]
-				else:
-					while len(pattern) < 3:
-						pattern.append("*")
-				patterns.append(pattern)
-			replacements = []
-			for p in repparts:
-				if not p:
-					print "Line", startlineno,
-					print "Empty replacement part"
-					print `line`
-					continue
-				replacement = p.split()
-				if len(replacement) > 3:
-					print "Line", startlineno,
-					print "Pattern part has > 3 words"
-					print `line`
-					replacement = replacement[:3]
-				else:
-					while len(replacement) < 3:
-						replacement.append("*")
-				replacements.append(replacement)
-			list.append((fpat, patterns, replacements))
-		return list
-		
-	def makeinherentpointertypes(self):
-		return []
-	
-	def openrepairfile(self, filename = "REPAIR"):
-		try:
-			return open(filename, "rU")
-		except IOError, msg:
-			print `filename`, ":", msg
-			print "Cannot open repair file -- assume no repair needed"
-			return None
+    def makerepairinstructions(self):
+        """Parse the repair file into repair instructions.
+        
+        The file format is simple:
+        1) use \ to split a long logical line in multiple physical lines
+        2) everything after the first # on a line is ignored (as comment)
+        3) empty lines are ignored
+        4) remaining lines must have exactly 3 colon-separated fields:
+           functionpattern : argumentspattern : argumentsreplacement
+        5) all patterns use shell style pattern matching
+        6) an empty functionpattern means the same as *
+        7) the other two fields are each comma-separated lists of triples
+        8) a triple is a space-separated list of 1-3 words
+        9) a triple with less than 3 words is padded at the end with "*" words
+        10) when used as a pattern, a triple matches the type, name, and mode
+            of an argument, respectively
+        11) when used as a replacement, the words of a triple specify
+            replacements for the corresponding words of the argument,
+            with "*" as a word by itself meaning leave the original word
+            (no other uses of "*" is allowed)
+        12) the replacement need not have the same number of triples
+            as the pattern
+        """
+        f = self.openrepairfile()
+        if not f: return []
+        print "Reading repair file", `f.name`, "..."
+        list = []
+        lineno = 0
+        while 1:
+            line = f.readline()
+            if not line: break
+            lineno = lineno + 1
+            startlineno = lineno
+            while line[-2:] == '\\\n':
+                line = line[:-2] + ' ' + f.readline()
+                lineno = lineno + 1
+            i = line.find('#')
+            if i >= 0: line = line[:i]
+            words = [s.strip() for s in line.split(':')]
+            if words == ['']: continue
+            if len(words) <> 3:
+                print "Line", startlineno,
+                print ": bad line (not 3 colon-separated fields)"
+                print `line`
+                continue
+            [fpat, pat, rep] = words
+            if not fpat: fpat = "*"
+            if not pat:
+                print "Line", startlineno,
+                print "Empty pattern"
+                print `line`
+                continue
+            patparts = [s.strip() for s in pat.split(',')]
+            repparts = [s.strip() for s in rep.split(',')]
+            patterns = []
+            for p in patparts:
+                if not p:
+                    print "Line", startlineno,
+                    print "Empty pattern part"
+                    print `line`
+                    continue
+                pattern = p.split()
+                if len(pattern) > 3:
+                    print "Line", startlineno,
+                    print "Pattern part has > 3 words"
+                    print `line`
+                    pattern = pattern[:3]
+                else:
+                    while len(pattern) < 3:
+                        pattern.append("*")
+                patterns.append(pattern)
+            replacements = []
+            for p in repparts:
+                if not p:
+                    print "Line", startlineno,
+                    print "Empty replacement part"
+                    print `line`
+                    continue
+                replacement = p.split()
+                if len(replacement) > 3:
+                    print "Line", startlineno,
+                    print "Pattern part has > 3 words"
+                    print `line`
+                    replacement = replacement[:3]
+                else:
+                    while len(replacement) < 3:
+                        replacement.append("*")
+                replacements.append(replacement)
+            list.append((fpat, patterns, replacements))
+        return list
+        
+    def makeinherentpointertypes(self):
+        return []
+    
+    def openrepairfile(self, filename = "REPAIR"):
+        try:
+            return open(filename, "rU")
+        except IOError, msg:
+            print `filename`, ":", msg
+            print "Cannot open repair file -- assume no repair needed"
+            return None
 
-	def initfiles(self):
-		self.specmine = 0
-		self.defsmine = 0
-		self.scanmine = 0
-		self.specfile = sys.stdout
-		self.defsfile = None
-		self.scanfile = sys.stdin
-		self.lineno = 0
-		self.line = ""
+    def initfiles(self):
+        self.specmine = 0
+        self.defsmine = 0
+        self.scanmine = 0
+        self.specfile = sys.stdout
+        self.defsfile = None
+        self.scanfile = sys.stdin
+        self.lineno = 0
+        self.line = ""
 
-	def initpaths(self):
-		self.includepath = [os.curdir, INCLUDEDIR]
+    def initpaths(self):
+        self.includepath = [os.curdir, INCLUDEDIR]
 
-	def initpatterns(self):
-		self.head_pat = r"^EXTERN_API[^_]"
-		self.tail_pat = r"[;={}]"
-		self.type_pat = r"EXTERN_API" + \
-						r"[ \t\n]*\([ \t\n]*" + \
-						r"(?P<type>[a-zA-Z0-9_* \t]*[a-zA-Z0-9_*])" + \
-						r"[ \t\n]*\)[ \t\n]*"
-		self.name_pat = r"(?P<name>[a-zA-Z0-9_]+)[ \t\n]*"
-		self.args_pat = r"\((?P<args>([^\(;=\)]+|\([^\(;=\)]*\))*)\)"
-		self.whole_pat = self.type_pat + self.name_pat + self.args_pat
-		self.sym_pat = r"^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
-		               r"[ \t]*(?P<defn>[-0-9_a-zA-Z'\"\(][^\t\n,;}]*),?"
-		self.asplit_pat = r"^(?P<type>.*[^a-zA-Z0-9_])(?P<name>[a-zA-Z0-9_]+)(?P<array>\[\])?$"
-		self.comment1_pat = r"(?P<rest>.*)//.*"
-		# note that the next pattern only removes comments that are wholly within one line
-		self.comment2_pat = r"(?P<rest1>.*)/\*.*\*/(?P<rest2>.*)"
+    def initpatterns(self):
+        self.head_pat = r"^EXTERN_API[^_]"
+        self.tail_pat = r"[;={}]"
+        self.type_pat = r"EXTERN_API" + \
+                        r"[ \t\n]*\([ \t\n]*" + \
+                        r"(?P<type>[a-zA-Z0-9_* \t]*[a-zA-Z0-9_*])" + \
+                        r"[ \t\n]*\)[ \t\n]*"
+        self.name_pat = r"(?P<name>[a-zA-Z0-9_]+)[ \t\n]*"
+        self.args_pat = r"\((?P<args>([^\(;=\)]+|\([^\(;=\)]*\))*)\)"
+        self.whole_pat = self.type_pat + self.name_pat + self.args_pat
+        self.sym_pat = r"^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
+                       r"[ \t]*(?P<defn>[-0-9_a-zA-Z'\"\(][^\t\n,;}]*),?"
+        self.asplit_pat = r"^(?P<type>.*[^a-zA-Z0-9_])(?P<name>[a-zA-Z0-9_]+)(?P<array>\[\])?$"
+        self.comment1_pat = r"(?P<rest>.*)//.*"
+        # note that the next pattern only removes comments that are wholly within one line
+        self.comment2_pat = r"(?P<rest1>.*)/\*.*\*/(?P<rest2>.*)"
 
-	def compilepatterns(self):
-		for name in dir(self):
-			if name[-4:] == "_pat":
-				pat = getattr(self, name)
-				prog = re.compile(pat)
-				setattr(self, name[:-4], prog)
+    def compilepatterns(self):
+        for name in dir(self):
+            if name[-4:] == "_pat":
+                pat = getattr(self, name)
+                prog = re.compile(pat)
+                setattr(self, name[:-4], prog)
 
-	def initosspecifics(self):
-		if MacOS and CREATOR:
-			self.filetype = 'TEXT'
-			self.filecreator = CREATOR
-		else:
-			self.filetype = self.filecreator = None
+    def initosspecifics(self):
+        if MacOS and CREATOR:
+            self.filetype = 'TEXT'
+            self.filecreator = CREATOR
+        else:
+            self.filetype = self.filecreator = None
 
-	def setfiletype(self, filename):
-		if MacOS and (self.filecreator or self.filetype):
-			creator, type = MacOS.GetCreatorAndType(filename)
-			if self.filecreator: creator = self.filecreator
-			if self.filetype: type = self.filetype
-			MacOS.SetCreatorAndType(filename, creator, type)
+    def setfiletype(self, filename):
+        if MacOS and (self.filecreator or self.filetype):
+            creator, type = MacOS.GetCreatorAndType(filename)
+            if self.filecreator: creator = self.filecreator
+            if self.filetype: type = self.filetype
+            MacOS.SetCreatorAndType(filename, creator, type)
 
-	def close(self):
-		self.closefiles()
+    def close(self):
+        self.closefiles()
 
-	def closefiles(self):
-		self.closespec()
-		self.closedefs()
-		self.closescan()
+    def closefiles(self):
+        self.closespec()
+        self.closedefs()
+        self.closescan()
 
-	def closespec(self):
-		tmp = self.specmine and self.specfile
-		self.specfile = None
-		if tmp: tmp.close()
+    def closespec(self):
+        tmp = self.specmine and self.specfile
+        self.specfile = None
+        if tmp: tmp.close()
 
-	def closedefs(self):
-		tmp = self.defsmine and self.defsfile
-		self.defsfile = None
-		if tmp: tmp.close()
+    def closedefs(self):
+        tmp = self.defsmine and self.defsfile
+        self.defsfile = None
+        if tmp: tmp.close()
 
-	def closescan(self):
-		tmp = self.scanmine and self.scanfile
-		self.scanfile = None
-		if tmp: tmp.close()
+    def closescan(self):
+        tmp = self.scanmine and self.scanfile
+        self.scanfile = None
+        if tmp: tmp.close()
 
-	def setoutput(self, spec, defs = None):
-		self.closespec()
-		self.closedefs()
-		if spec:
-			if type(spec) == StringType:
-				file = self.openoutput(spec)
-				mine = 1
-			else:
-				file = spec
-				mine = 0
-			self.specfile = file
-			self.specmine = mine
-		if defs:
-			if type(defs) == StringType:
-				file = self.openoutput(defs)
-				mine = 1
-			else:
-				file = defs
-				mine = 0
-			self.defsfile = file
-			self.defsmine = mine
+    def setoutput(self, spec, defs = None):
+        self.closespec()
+        self.closedefs()
+        if spec:
+            if type(spec) == StringType:
+                file = self.openoutput(spec)
+                mine = 1
+            else:
+                file = spec
+                mine = 0
+            self.specfile = file
+            self.specmine = mine
+        if defs:
+            if type(defs) == StringType:
+                file = self.openoutput(defs)
+                mine = 1
+            else:
+                file = defs
+                mine = 0
+            self.defsfile = file
+            self.defsmine = mine
 
-	def openoutput(self, filename):
-		try:
-			file = open(filename, 'w')
-		except IOError, arg:
-			raise IOError, (filename, arg)
-		self.setfiletype(filename)
-		return file
+    def openoutput(self, filename):
+        try:
+            file = open(filename, 'w')
+        except IOError, arg:
+            raise IOError, (filename, arg)
+        self.setfiletype(filename)
+        return file
 
-	def setinput(self, scan = sys.stdin):
-		if not type(scan) in (TupleType, ListType):
-			scan = [scan]
-		self.allscaninputs = scan
-		self._nextinput()
-		
-	def _nextinput(self):
-		if not self.allscaninputs:
-			return 0
-		scan = self.allscaninputs[0]
-		self.allscaninputs = self.allscaninputs[1:]
-		self.closescan()
-		if scan:
-			if type(scan) == StringType:
-				file = self.openinput(scan)
-				mine = 1
-			else:
-				file = scan
-				mine = 0
-			self.scanfile = file
-			self.scanmine = mine
-		self.lineno = 0
-		return 1
+    def setinput(self, scan = sys.stdin):
+        if not type(scan) in (TupleType, ListType):
+            scan = [scan]
+        self.allscaninputs = scan
+        self._nextinput()
+        
+    def _nextinput(self):
+        if not self.allscaninputs:
+            return 0
+        scan = self.allscaninputs[0]
+        self.allscaninputs = self.allscaninputs[1:]
+        self.closescan()
+        if scan:
+            if type(scan) == StringType:
+                file = self.openinput(scan)
+                mine = 1
+            else:
+                file = scan
+                mine = 0
+            self.scanfile = file
+            self.scanmine = mine
+        self.lineno = 0
+        return 1
 
-	def openinput(self, filename):
-		if not os.path.isabs(filename):
-			for dir in self.includepath:
-				fullname = os.path.join(dir, filename)
-				#self.report("trying full name %s", `fullname`)
-				try:
-					return open(fullname, 'rU')
-				except IOError:
-					pass
-		# If not on the path, or absolute, try default open()
-		try:
-			return open(filename, 'rU')
-		except IOError, arg:
-			raise IOError, (arg, filename)
+    def openinput(self, filename):
+        if not os.path.isabs(filename):
+            for dir in self.includepath:
+                fullname = os.path.join(dir, filename)
+                #self.report("trying full name %s", `fullname`)
+                try:
+                    return open(fullname, 'rU')
+                except IOError:
+                    pass
+        # If not on the path, or absolute, try default open()
+        try:
+            return open(filename, 'rU')
+        except IOError, arg:
+            raise IOError, (arg, filename)
 
-	def getline(self):
-		if not self.scanfile:
-			raise Error, "input file not set"
-		self.line = self.scanfile.readline()
-		if not self.line:
-			if self._nextinput():
-				return self.getline()
-			raise EOFError
-		self.lineno = self.lineno + 1
-		return self.line
+    def getline(self):
+        if not self.scanfile:
+            raise Error, "input file not set"
+        self.line = self.scanfile.readline()
+        if not self.line:
+            if self._nextinput():
+                return self.getline()
+            raise EOFError
+        self.lineno = self.lineno + 1
+        return self.line
 
-	def scan(self):
-		if not self.scanfile:
-			self.error("No input file has been specified")
-			return
-		inputname = self.scanfile.name
-		self.report("scanfile = %s", `inputname`)
-		if not self.specfile:
-			self.report("(No interface specifications will be written)")
-		else:
-			self.report("specfile = %s", `self.specfile.name`)
-			self.specfile.write("# Generated from %s\n\n" % `inputname`)
-		if not self.defsfile:
-			self.report("(No symbol definitions will be written)")
-		else:
-			self.report("defsfile = %s", `self.defsfile.name`)
-			self.defsfile.write("# Generated from %s\n\n" % `os.path.split(inputname)[1]`)
-			self.writeinitialdefs()
-		self.alreadydone = []
-		try:
-			while 1:
-				try: line = self.getline()
-				except EOFError: break
-				if self.debug:
-					self.report("LINE: %s" % `line`)
-				match = self.comment1.match(line)
-				if match:
-					line = match.group('rest')
-					if self.debug:
-						self.report("\tafter comment1: %s" % `line`)
-				match = self.comment2.match(line)
-				while match:
-					line = match.group('rest1')+match.group('rest2')
-					if self.debug:
-						self.report("\tafter comment2: %s" % `line`)
-					match = self.comment2.match(line)
-				if self.defsfile:
-					match = self.sym.match(line)
-					if match:
-						if self.debug:
-							self.report("\tmatches sym.")
-						self.dosymdef(match)
-						continue
-				match = self.head.match(line)
-				if match:
-					if self.debug:
-						self.report("\tmatches head.")
-					self.dofuncspec()
-					continue
-		except EOFError:
-			self.error("Uncaught EOF error")
-		self.reportusedtypes()
+    def scan(self):
+        if not self.scanfile:
+            self.error("No input file has been specified")
+            return
+        inputname = self.scanfile.name
+        self.report("scanfile = %s", `inputname`)
+        if not self.specfile:
+            self.report("(No interface specifications will be written)")
+        else:
+            self.report("specfile = %s", `self.specfile.name`)
+            self.specfile.write("# Generated from %s\n\n" % `inputname`)
+        if not self.defsfile:
+            self.report("(No symbol definitions will be written)")
+        else:
+            self.report("defsfile = %s", `self.defsfile.name`)
+            self.defsfile.write("# Generated from %s\n\n" % `os.path.split(inputname)[1]`)
+            self.writeinitialdefs()
+        self.alreadydone = []
+        try:
+            while 1:
+                try: line = self.getline()
+                except EOFError: break
+                if self.debug:
+                    self.report("LINE: %s" % `line`)
+                match = self.comment1.match(line)
+                if match:
+                    line = match.group('rest')
+                    if self.debug:
+                        self.report("\tafter comment1: %s" % `line`)
+                match = self.comment2.match(line)
+                while match:
+                    line = match.group('rest1')+match.group('rest2')
+                    if self.debug:
+                        self.report("\tafter comment2: %s" % `line`)
+                    match = self.comment2.match(line)
+                if self.defsfile:
+                    match = self.sym.match(line)
+                    if match:
+                        if self.debug:
+                            self.report("\tmatches sym.")
+                        self.dosymdef(match)
+                        continue
+                match = self.head.match(line)
+                if match:
+                    if self.debug:
+                        self.report("\tmatches head.")
+                    self.dofuncspec()
+                    continue
+        except EOFError:
+            self.error("Uncaught EOF error")
+        self.reportusedtypes()
 
-	def dosymdef(self, match):
-		name, defn = match.group('name', 'defn')
-		defn = escape8bit(defn)
-		if self.debug:
-			self.report("\tsym: name=%s, defn=%s" % (`name`, `defn`))
-		if not name in self.blacklistnames:
-			self.defsfile.write("%s = %s\n" % (name, defn))
-		else:
-			self.defsfile.write("# %s = %s\n" % (name, defn))
-		# XXXX No way to handle greylisted names
+    def dosymdef(self, match):
+        name, defn = match.group('name', 'defn')
+        defn = escape8bit(defn)
+        if self.debug:
+            self.report("\tsym: name=%s, defn=%s" % (`name`, `defn`))
+        if not name in self.blacklistnames:
+            self.defsfile.write("%s = %s\n" % (name, defn))
+        else:
+            self.defsfile.write("# %s = %s\n" % (name, defn))
+        # XXXX No way to handle greylisted names
 
-	def dofuncspec(self):
-		raw = self.line
-		while not self.tail.search(raw):
-			line = self.getline()
-			if self.debug:
-				self.report("* CONTINUATION LINE: %s" % `line`)
-			match = self.comment1.match(line)
-			if match:
-				line = match.group('rest')
-				if self.debug:
-					self.report("\tafter comment1: %s" % `line`)
-			match = self.comment2.match(line)
-			while match:
-				line = match.group('rest1')+match.group('rest2')
-				if self.debug:
-					self.report("\tafter comment1: %s" % `line`)
-				match = self.comment2.match(line)
-			raw = raw + line
-		if self.debug:
-			self.report("* WHOLE LINE: %s" % `raw`)
-		self.processrawspec(raw)
+    def dofuncspec(self):
+        raw = self.line
+        while not self.tail.search(raw):
+            line = self.getline()
+            if self.debug:
+                self.report("* CONTINUATION LINE: %s" % `line`)
+            match = self.comment1.match(line)
+            if match:
+                line = match.group('rest')
+                if self.debug:
+                    self.report("\tafter comment1: %s" % `line`)
+            match = self.comment2.match(line)
+            while match:
+                line = match.group('rest1')+match.group('rest2')
+                if self.debug:
+                    self.report("\tafter comment1: %s" % `line`)
+                match = self.comment2.match(line)
+            raw = raw + line
+        if self.debug:
+            self.report("* WHOLE LINE: %s" % `raw`)
+        self.processrawspec(raw)
 
-	def processrawspec(self, raw):
-		match = self.whole.search(raw)
-		if not match:
-			self.report("Bad raw spec: %s", `raw`)
-			if self.debug:
-				if not self.type.search(raw):
-					self.report("(Type already doesn't match)")
-				else:
-					self.report("(but type matched)")
-			return
-		type, name, args = match.group('type', 'name', 'args')
-		type = re.sub("\*", " ptr", type)
-		type = re.sub("[ \t]+", "_", type)
-		if name in self.alreadydone:
-			self.report("Name has already been defined: %s", `name`)
-			return
-		self.report("==> %s %s <==", type, name)
-		if self.blacklisted(type, name):
-			self.report("*** %s %s blacklisted", type, name)
-			return
-		returnlist = [(type, name, 'ReturnMode')]
-		returnlist = self.repairarglist(name, returnlist)
-		[(type, name, returnmode)] = returnlist
-		arglist = self.extractarglist(args)
-		arglist = self.repairarglist(name, arglist)
-		if self.unmanageable(type, name, arglist):
-			##for arg in arglist:
-			##	self.report("    %s", `arg`)
-			self.report("*** %s %s unmanageable", type, name)
-			return
-		self.alreadydone.append(name)
-		self.generate(type, name, arglist)
+    def processrawspec(self, raw):
+        match = self.whole.search(raw)
+        if not match:
+            self.report("Bad raw spec: %s", `raw`)
+            if self.debug:
+                if not self.type.search(raw):
+                    self.report("(Type already doesn't match)")
+                else:
+                    self.report("(but type matched)")
+            return
+        type, name, args = match.group('type', 'name', 'args')
+        type = re.sub("\*", " ptr", type)
+        type = re.sub("[ \t]+", "_", type)
+        if name in self.alreadydone:
+            self.report("Name has already been defined: %s", `name`)
+            return
+        self.report("==> %s %s <==", type, name)
+        if self.blacklisted(type, name):
+            self.report("*** %s %s blacklisted", type, name)
+            return
+        returnlist = [(type, name, 'ReturnMode')]
+        returnlist = self.repairarglist(name, returnlist)
+        [(type, name, returnmode)] = returnlist
+        arglist = self.extractarglist(args)
+        arglist = self.repairarglist(name, arglist)
+        if self.unmanageable(type, name, arglist):
+            ##for arg in arglist:
+            ##  self.report("    %s", `arg`)
+            self.report("*** %s %s unmanageable", type, name)
+            return
+        self.alreadydone.append(name)
+        self.generate(type, name, arglist)
 
-	def extractarglist(self, args):
-		args = args.strip()
-		if not args or args == "void":
-			return []
-		parts = [s.strip() for s in args.split(",")]
-		arglist = []
-		for part in parts:
-			arg = self.extractarg(part)
-			arglist.append(arg)
-		return arglist
+    def extractarglist(self, args):
+        args = args.strip()
+        if not args or args == "void":
+            return []
+        parts = [s.strip() for s in args.split(",")]
+        arglist = []
+        for part in parts:
+            arg = self.extractarg(part)
+            arglist.append(arg)
+        return arglist
 
-	def extractarg(self, part):
-		mode = "InMode"
-		part = part.strip()
-		match = self.asplit.match(part)
-		if not match:
-			self.error("Indecipherable argument: %s", `part`)
-			return ("unknown", part, mode)
-		type, name, array = match.group('type', 'name', 'array')
-		if array:
-			# array matches an optional [] after the argument name
-			type = type + " ptr "
-		type = re.sub("\*", " ptr ", type)
-		type = type.strip()
-		type = re.sub("[ \t]+", "_", type)
-		return self.modifyarg(type, name, mode)
-	
-	def modifyarg(self, type, name, mode):
-		if type[:6] == "const_":
-			type = type[6:]
-		elif type[-4:] == "_ptr":
-			type = type[:-4]
-			mode = "OutMode"
-		elif type in self.inherentpointertypes:
-			mode = "OutMode"
-		if type[-4:] == "_far":
-			type = type[:-4]
-		return type, name, mode
+    def extractarg(self, part):
+        mode = "InMode"
+        part = part.strip()
+        match = self.asplit.match(part)
+        if not match:
+            self.error("Indecipherable argument: %s", `part`)
+            return ("unknown", part, mode)
+        type, name, array = match.group('type', 'name', 'array')
+        if array:
+            # array matches an optional [] after the argument name
+            type = type + " ptr "
+        type = re.sub("\*", " ptr ", type)
+        type = type.strip()
+        type = re.sub("[ \t]+", "_", type)
+        return self.modifyarg(type, name, mode)
+    
+    def modifyarg(self, type, name, mode):
+        if type[:6] == "const_":
+            type = type[6:]
+        elif type[-4:] == "_ptr":
+            type = type[:-4]
+            mode = "OutMode"
+        elif type in self.inherentpointertypes:
+            mode = "OutMode"
+        if type[-4:] == "_far":
+            type = type[:-4]
+        return type, name, mode
 
-	def repairarglist(self, functionname, arglist):
-		arglist = arglist[:]
-		i = 0
-		while i < len(arglist):
-			for item in self.repairinstructions:
-				if len(item) == 2:
-					pattern, replacement = item
-					functionpat = "*"
-				else:
-					functionpat, pattern, replacement = item
-				if not fnmatch.fnmatchcase(functionname, functionpat):
-					continue
-				n = len(pattern)
-				if i+n > len(arglist): continue
-				current = arglist[i:i+n]
-				for j in range(n):
-					if not self.matcharg(pattern[j], current[j]):
-						break
-				else: # All items of the pattern match
-					new = self.substituteargs(
-							pattern, replacement, current)
-					if new is not None:
-						arglist[i:i+n] = new
-						i = i+len(new) # No recursive substitutions
-						break
-			else: # No patterns match
-				i = i+1
-		return arglist
-	
-	def matcharg(self, patarg, arg):
-		return len(filter(None, map(fnmatch.fnmatchcase, arg, patarg))) == 3
+    def repairarglist(self, functionname, arglist):
+        arglist = arglist[:]
+        i = 0
+        while i < len(arglist):
+            for item in self.repairinstructions:
+                if len(item) == 2:
+                    pattern, replacement = item
+                    functionpat = "*"
+                else:
+                    functionpat, pattern, replacement = item
+                if not fnmatch.fnmatchcase(functionname, functionpat):
+                    continue
+                n = len(pattern)
+                if i+n > len(arglist): continue
+                current = arglist[i:i+n]
+                for j in range(n):
+                    if not self.matcharg(pattern[j], current[j]):
+                        break
+                else: # All items of the pattern match
+                    new = self.substituteargs(
+                            pattern, replacement, current)
+                    if new is not None:
+                        arglist[i:i+n] = new
+                        i = i+len(new) # No recursive substitutions
+                        break
+            else: # No patterns match
+                i = i+1
+        return arglist
+    
+    def matcharg(self, patarg, arg):
+        return len(filter(None, map(fnmatch.fnmatchcase, arg, patarg))) == 3
 
-	def substituteargs(self, pattern, replacement, old):
-		new = []
-		for k in range(len(replacement)):
-			item = replacement[k]
-			newitem = [item[0], item[1], item[2]]
-			for i in range(3):
-				if item[i] == '*':
-					newitem[i] = old[k][i]
-				elif item[i][:1] == '$':
-					index = int(item[i][1:]) - 1
-					newitem[i] = old[index][i]
-			new.append(tuple(newitem))
-		##self.report("old: %s", `old`)
-		##self.report("new: %s", `new`)
-		return new
+    def substituteargs(self, pattern, replacement, old):
+        new = []
+        for k in range(len(replacement)):
+            item = replacement[k]
+            newitem = [item[0], item[1], item[2]]
+            for i in range(3):
+                if item[i] == '*':
+                    newitem[i] = old[k][i]
+                elif item[i][:1] == '$':
+                    index = int(item[i][1:]) - 1
+                    newitem[i] = old[index][i]
+            new.append(tuple(newitem))
+        ##self.report("old: %s", `old`)
+        ##self.report("new: %s", `new`)
+        return new
 
-	def generate(self, type, name, arglist):
-		self.typeused(type, 'return')
-		classname, listname = self.destination(type, name, arglist)
-		if not self.specfile: return
-		self.specfile.write("f = %s(%s, %s,\n" % (classname, type, `name`))
-		for atype, aname, amode in arglist:
-			self.typeused(atype, amode)
-			self.specfile.write("    (%s, %s, %s),\n" %
-			                    (atype, `aname`, amode))
-		if self.greydictnames.has_key(name):
-			self.specfile.write("    condition=%s,\n"%`self.greydictnames[name]`)
-		self.specfile.write(")\n")
-		self.specfile.write("%s.append(f)\n\n" % listname)
+    def generate(self, type, name, arglist):
+        self.typeused(type, 'return')
+        classname, listname = self.destination(type, name, arglist)
+        if not self.specfile: return
+        self.specfile.write("f = %s(%s, %s,\n" % (classname, type, `name`))
+        for atype, aname, amode in arglist:
+            self.typeused(atype, amode)
+            self.specfile.write("    (%s, %s, %s),\n" %
+                                (atype, `aname`, amode))
+        if self.greydictnames.has_key(name):
+            self.specfile.write("    condition=%s,\n"%`self.greydictnames[name]`)
+        self.specfile.write(")\n")
+        self.specfile.write("%s.append(f)\n\n" % listname)
 
-	def destination(self, type, name, arglist):
-		return "FunctionGenerator", "functions"
+    def destination(self, type, name, arglist):
+        return "FunctionGenerator", "functions"
 
-	def blacklisted(self, type, name):
-		if type in self.blacklisttypes:
-			##self.report("return type %s is blacklisted", type)
-			return 1
-		if name in self.blacklistnames:
-			##self.report("function name %s is blacklisted", name)
-			return 1
-		return 0
+    def blacklisted(self, type, name):
+        if type in self.blacklisttypes:
+            ##self.report("return type %s is blacklisted", type)
+            return 1
+        if name in self.blacklistnames:
+            ##self.report("function name %s is blacklisted", name)
+            return 1
+        return 0
 
-	def unmanageable(self, type, name, arglist):
-		for atype, aname, amode in arglist:
-			if atype in self.blacklisttypes:
-				self.report("argument type %s is blacklisted", atype)
-				return 1
-		return 0
+    def unmanageable(self, type, name, arglist):
+        for atype, aname, amode in arglist:
+            if atype in self.blacklisttypes:
+                self.report("argument type %s is blacklisted", atype)
+                return 1
+        return 0
 
 class Scanner_PreUH3(Scanner):
-	"""Scanner for Universal Headers before release 3"""
-	def initpatterns(self):
-		Scanner.initpatterns(self)
-		self.head_pat = "^extern pascal[ \t]+" # XXX Mac specific!
-		self.type_pat = "pascal[ \t\n]+(?P<type>[a-zA-Z0-9_ \t]*[a-zA-Z0-9_])[ \t\n]+"
-		self.whole_pat = self.type_pat + self.name_pat + self.args_pat
-		self.sym_pat = "^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
-		               "[ \t]*(?P<defn>[-0-9'\"][^\t\n,;}]*),?"
+    """Scanner for Universal Headers before release 3"""
+    def initpatterns(self):
+        Scanner.initpatterns(self)
+        self.head_pat = "^extern pascal[ \t]+" # XXX Mac specific!
+        self.type_pat = "pascal[ \t\n]+(?P<type>[a-zA-Z0-9_ \t]*[a-zA-Z0-9_])[ \t\n]+"
+        self.whole_pat = self.type_pat + self.name_pat + self.args_pat
+        self.sym_pat = "^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
+                       "[ \t]*(?P<defn>[-0-9'\"][^\t\n,;}]*),?"
 
 class Scanner_OSX(Scanner):
-	"""Scanner for modern (post UH3.3) Universal Headers """
-	def initpatterns(self):
-		Scanner.initpatterns(self)
-		self.head_pat = "^EXTERN_API(_C)?"
-		self.type_pat = "EXTERN_API(_C)?" + \
-						"[ \t\n]*\([ \t\n]*" + \
-						"(?P<type>[a-zA-Z0-9_* \t]*[a-zA-Z0-9_*])" + \
-						"[ \t\n]*\)[ \t\n]*"
-		self.whole_pat = self.type_pat + self.name_pat + self.args_pat
-		self.sym_pat = "^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
-		               "[ \t]*(?P<defn>[-0-9_a-zA-Z'\"\(][^\t\n,;}]*),?"
+    """Scanner for modern (post UH3.3) Universal Headers """
+    def initpatterns(self):
+        Scanner.initpatterns(self)
+        self.head_pat = "^EXTERN_API(_C)?"
+        self.type_pat = "EXTERN_API(_C)?" + \
+                        "[ \t\n]*\([ \t\n]*" + \
+                        "(?P<type>[a-zA-Z0-9_* \t]*[a-zA-Z0-9_*])" + \
+                        "[ \t\n]*\)[ \t\n]*"
+        self.whole_pat = self.type_pat + self.name_pat + self.args_pat
+        self.sym_pat = "^[ \t]*(?P<name>[a-zA-Z0-9_]+)[ \t]*=" + \
+                       "[ \t]*(?P<defn>[-0-9_a-zA-Z'\"\(][^\t\n,;}]*),?"
 
 _8bit = re.compile(r"[\200-\377]")
 
 def escape8bit(s):
-	if _8bit.search(s) is not None:
-		out = []
-		for c in s:
-			o = ord(c)
-			if o >= 128:
-				out.append("\\" + hex(o)[1:])
-			else:
-				out.append(c)
-		s = "".join(out)
-	return s
+    if _8bit.search(s) is not None:
+        out = []
+        for c in s:
+            o = ord(c)
+            if o >= 128:
+                out.append("\\" + hex(o)[1:])
+            else:
+                out.append(c)
+        s = "".join(out)
+    return s
 
 def test():
-	input = "D:Development:THINK C:Mac #includes:Apple #includes:AppleEvents.h"
-	output = "@aespecs.py"
-	defsoutput = "@aedefs.py"
-	s = Scanner(input, output, defsoutput)
-	s.scan()
+    input = "D:Development:THINK C:Mac #includes:Apple #includes:AppleEvents.h"
+    output = "@aespecs.py"
+    defsoutput = "@aedefs.py"
+    s = Scanner(input, output, defsoutput)
+    s.scan()
 
 if __name__ == '__main__':
-	test()
+    test()