1 files changed, 178 insertions, 178 deletions

diff --git a/Mac/Modules/snd/sndsupport.py b/Mac/Modules/snd/sndsupport.py
index 99df5be..cf0fa6c 100644
--- a/Mac/Modules/snd/sndsupport.py
+++ b/Mac/Modules/snd/sndsupport.py
@@ -27,12 +27,12 @@ initstuff = initstuff + """
 # define types used for arguments (in addition to standard and macsupport types)
 
 class SndChannelPtrType(OpaqueByValueType):
-	def declare(self, name):
-		# Initializing all SndChannelPtr objects to 0 saves
-		# special-casing NewSndChannel(), where it is formally an
-		# input-output parameter but we treat it as output-only
-		# (since Python users are not supposed to allocate memory)
-		Output("SndChannelPtr %s = 0;", name)
+    def declare(self, name):
+        # Initializing all SndChannelPtr objects to 0 saves
+        # special-casing NewSndChannel(), where it is formally an
+        # input-output parameter but we treat it as output-only
+        # (since Python users are not supposed to allocate memory)
+        Output("SndChannelPtr %s = 0;", name)
 
 SndChannelPtr = SndChannelPtrType('SndChannelPtr', 'SndCh')
 
@@ -49,28 +49,28 @@ ModalFilterUPP = FakeType("(ModalFilterUPP)0")
 void_ptr = Type("void *", "w")
 
 class SndCallBackType(InputOnlyType):
-	def __init__(self):
-		Type.__init__(self, 'PyObject*', 'O')
-	def getargsCheck(self, name):
-		Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
-		OutLbrace()
-		Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
-		Output("goto %s__error__;", name)
-		OutRbrace()
-	def passInput(self, name):
-		return "NewSndCallBackUPP(SndCh_UserRoutine)"
-	def cleanup(self, name):
-		# XXX This knows it is executing inside the SndNewChannel wrapper
-		Output("if (_res != NULL && %s != Py_None)", name)
-		OutLbrace()
-		Output("SndChannelObject *p = (SndChannelObject *)_res;")
-		Output("p->ob_itself->userInfo = (long)p;")
-		Output("Py_INCREF(%s);", name)
-		Output("p->ob_callback = %s;", name)
-		OutRbrace()
-		DedentLevel()
-		Output(" %s__error__: ;", name)
-		IndentLevel()
+    def __init__(self):
+        Type.__init__(self, 'PyObject*', 'O')
+    def getargsCheck(self, name):
+        Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
+        OutLbrace()
+        Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
+        Output("goto %s__error__;", name)
+        OutRbrace()
+    def passInput(self, name):
+        return "NewSndCallBackUPP(SndCh_UserRoutine)"
+    def cleanup(self, name):
+        # XXX This knows it is executing inside the SndNewChannel wrapper
+        Output("if (_res != NULL && %s != Py_None)", name)
+        OutLbrace()
+        Output("SndChannelObject *p = (SndChannelObject *)_res;")
+        Output("p->ob_itself->userInfo = (long)p;")
+        Output("Py_INCREF(%s);", name)
+        Output("p->ob_callback = %s;", name)
+        OutRbrace()
+        DedentLevel()
+        Output(" %s__error__: ;", name)
+        IndentLevel()
 
 SndCallBackProcPtr = SndCallBackType()
 SndCallBackUPP = SndCallBackProcPtr
@@ -95,16 +95,16 @@ includestuff = includestuff + """
 static int
 SndCmd_Convert(PyObject *v, SndCommand *pc)
 {
-	int len;
-	pc->param1 = 0;
-	pc->param2 = 0;
-	if (PyTuple_Check(v)) {
-		if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
-			return 1;
-		PyErr_Clear();
-		return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
-	}
-	return PyArg_Parse(v, "H", &pc->cmd);
+        int len;
+        pc->param1 = 0;
+        pc->param2 = 0;
+        if (PyTuple_Check(v)) {
+                if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
+                        return 1;
+                PyErr_Clear();
+                return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
+        }
+        return PyArg_Parse(v, "H", &pc->cmd);
 }
 
 static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
@@ -117,62 +117,62 @@ finalstuff = finalstuff + """
 static int
 SndCh_CallCallBack(void *arg)
 {
-	SndChannelObject *p = (SndChannelObject *)arg;
-	PyObject *args;
-	PyObject *res;
-	args = Py_BuildValue("(O(hhl))",
-	                     p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
-	res = PyEval_CallObject(p->ob_callback, args);
-	Py_DECREF(args);
-	if (res == NULL)
-		return -1;
-	Py_DECREF(res);
-	return 0;
+        SndChannelObject *p = (SndChannelObject *)arg;
+        PyObject *args;
+        PyObject *res;
+        args = Py_BuildValue("(O(hhl))",
+                             p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
+        res = PyEval_CallObject(p->ob_callback, args);
+        Py_DECREF(args);
+        if (res == NULL)
+                return -1;
+        Py_DECREF(res);
+        return 0;
 }
 
 /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
 static pascal void
 SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
 {
-	SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
-	if (p->ob_callback != NULL) {
-		long A5 = SetA5(p->ob_A5);
-		p->ob_cmd = *cmd;
-		Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
-		SetA5(A5);
-	}
+        SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
+        if (p->ob_callback != NULL) {
+                long A5 = SetA5(p->ob_A5);
+                p->ob_cmd = *cmd;
+                Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
+                SetA5(A5);
+        }
 }
 
 /* SPB callbacks - Schedule callbacks to Python */
 static int
 SPB_CallCallBack(void *arg)
 {
-	SPBObject *p = (SPBObject *)arg;
-	PyObject *args;
-	PyObject *res;
-	
-	if ( p->ob_thiscallback == 0 ) return 0;
-	args = Py_BuildValue("(O)", p);
-	res = PyEval_CallObject(p->ob_thiscallback, args);
-	p->ob_thiscallback = 0;
-	Py_DECREF(args);
-	if (res == NULL)
-		return -1;
-	Py_DECREF(res);
-	return 0;
+        SPBObject *p = (SPBObject *)arg;
+        PyObject *args;
+        PyObject *res;
+
+        if ( p->ob_thiscallback == 0 ) return 0;
+        args = Py_BuildValue("(O)", p);
+        res = PyEval_CallObject(p->ob_thiscallback, args);
+        p->ob_thiscallback = 0;
+        Py_DECREF(args);
+        if (res == NULL)
+                return -1;
+        Py_DECREF(res);
+        return 0;
 }
 
 static pascal void
 SPB_completion(SPBPtr my_spb)
 {
-	SPBObject *p = (SPBObject *)(my_spb->userLong);
-	
-	if (p && p->ob_completion) {
-		long A5 = SetA5(p->ob_A5);
-		p->ob_thiscallback = p->ob_completion;	/* Hope we cannot get two at the same time */
-		Py_AddPendingCall(SPB_CallCallBack, (void *)p);
-		SetA5(A5);
-	}
+        SPBObject *p = (SPBObject *)(my_spb->userLong);
+
+        if (p && p->ob_completion) {
+                long A5 = SetA5(p->ob_A5);
+                p->ob_thiscallback = p->ob_completion;  /* Hope we cannot get two at the same time */
+                Py_AddPendingCall(SPB_CallCallBack, (void *)p);
+                SetA5(A5);
+        }
 }
 
 """
@@ -182,110 +182,110 @@ SPB_completion(SPBPtr my_spb)
 
 class SndObjectDefinition(PEP252Mixin, ObjectDefinition):
 
-	def outputStructMembers(self):
-		ObjectDefinition.outputStructMembers(self)
-		Output("/* Members used to implement callbacks: */")
-		Output("PyObject *ob_callback;")
-		Output("long ob_A5;");
-		Output("SndCommand ob_cmd;")
-
-	def outputInitStructMembers(self):
-		ObjectDefinition.outputInitStructMembers(self)
-		Output("it->ob_callback = NULL;")
-		Output("it->ob_A5 = SetCurrentA5();");
-
-	def outputCleanupStructMembers(self):
-		ObjectDefinition.outputCleanupStructMembers(self)
-		Output("Py_XDECREF(self->ob_callback);")
-	
-	def outputFreeIt(self, itselfname):
-		Output("SndDisposeChannel(%s, 1);", itselfname)
-		
-	def outputConvert(self):
-		pass # Not needed
-		
+    def outputStructMembers(self):
+        ObjectDefinition.outputStructMembers(self)
+        Output("/* Members used to implement callbacks: */")
+        Output("PyObject *ob_callback;")
+        Output("long ob_A5;");
+        Output("SndCommand ob_cmd;")
+
+    def outputInitStructMembers(self):
+        ObjectDefinition.outputInitStructMembers(self)
+        Output("it->ob_callback = NULL;")
+        Output("it->ob_A5 = SetCurrentA5();");
+
+    def outputCleanupStructMembers(self):
+        ObjectDefinition.outputCleanupStructMembers(self)
+        Output("Py_XDECREF(self->ob_callback);")
+
+    def outputFreeIt(self, itselfname):
+        Output("SndDisposeChannel(%s, 1);", itselfname)
+
+    def outputConvert(self):
+        pass # Not needed
+
 #
 
 class SpbObjectDefinition(PEP252Mixin, ObjectDefinition):
-	getsetlist = [
-		(
-		'inRefNum',
-		'return Py_BuildValue("l", self->ob_spb.inRefNum);',
-		'return -1 + PyArg_Parse(v, "l", &self->ob_spb.inRefNum);',
-		None,
-		), (
-		'count',
-		'return Py_BuildValue("l", self->ob_spb.count);',
-		'return -1 + PyArg_Parse(v, "l", &self->ob_spb.count);',
-		None
-		), (
-		'milliseconds',
-		'return Py_BuildValue("l", self->ob_spb.milliseconds);',
-		'return -1 + PyArg_Parse(v, "l", &self->ob_spb.milliseconds);',
-		None,
-		), (
-		'error',
-		'return Py_BuildValue("h", self->ob_spb.error);',
-		None,
-		None
-		), (
-		'completionRoutine',
-		None,
-		"""self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
-		self->ob_completion = v;
-		Py_INCREF(v);
-		return 0;""",
-		None,
-		)]
-
-	def outputStructMembers(self):
-		Output("/* Members used to implement callbacks: */")
-		Output("PyObject *ob_completion;")
-		Output("PyObject *ob_interrupt;")
-		Output("PyObject *ob_thiscallback;");
-		Output("long ob_A5;")
-		Output("SPB ob_spb;")
-
-	def outputNew(self):
-		Output()
-		Output("%sPyObject *%s_New(void)", self.static, self.prefix)
-		OutLbrace()
-		Output("%s *it;", self.objecttype)
-		self.outputCheckNewArg()
-		Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
-		Output("if (it == NULL) return NULL;")
-		self.outputInitStructMembers()
-		Output("return (PyObject *)it;")
-		OutRbrace()
-
-	def outputInitStructMembers(self):
-		Output("it->ob_completion = NULL;")
-		Output("it->ob_interrupt = NULL;")
-		Output("it->ob_thiscallback = NULL;")
-		Output("it->ob_A5 = SetCurrentA5();")
-		Output("memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));")
-		Output("it->ob_spb.userLong = (long)it;")
-
-	def outputCleanupStructMembers(self):
-		ObjectDefinition.outputCleanupStructMembers(self)
-		Output("self->ob_spb.userLong = 0;")
-		Output("self->ob_thiscallback = 0;")
-		Output("Py_XDECREF(self->ob_completion);")
-		Output("Py_XDECREF(self->ob_interrupt);")
-	
-	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_spb;", self.objecttype)
-		Output("return 1;")
-		OutRbrace()
-					
+    getsetlist = [
+            (
+            'inRefNum',
+            'return Py_BuildValue("l", self->ob_spb.inRefNum);',
+            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.inRefNum);',
+            None,
+            ), (
+            'count',
+            'return Py_BuildValue("l", self->ob_spb.count);',
+            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.count);',
+            None
+            ), (
+            'milliseconds',
+            'return Py_BuildValue("l", self->ob_spb.milliseconds);',
+            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.milliseconds);',
+            None,
+            ), (
+            'error',
+            'return Py_BuildValue("h", self->ob_spb.error);',
+            None,
+            None
+            ), (
+            'completionRoutine',
+            None,
+            """self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
+            self->ob_completion = v;
+            Py_INCREF(v);
+            return 0;""",
+            None,
+            )]
+
+    def outputStructMembers(self):
+        Output("/* Members used to implement callbacks: */")
+        Output("PyObject *ob_completion;")
+        Output("PyObject *ob_interrupt;")
+        Output("PyObject *ob_thiscallback;");
+        Output("long ob_A5;")
+        Output("SPB ob_spb;")
+
+    def outputNew(self):
+        Output()
+        Output("%sPyObject *%s_New(void)", self.static, self.prefix)
+        OutLbrace()
+        Output("%s *it;", self.objecttype)
+        self.outputCheckNewArg()
+        Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
+        Output("if (it == NULL) return NULL;")
+        self.outputInitStructMembers()
+        Output("return (PyObject *)it;")
+        OutRbrace()
+
+    def outputInitStructMembers(self):
+        Output("it->ob_completion = NULL;")
+        Output("it->ob_interrupt = NULL;")
+        Output("it->ob_thiscallback = NULL;")
+        Output("it->ob_A5 = SetCurrentA5();")
+        Output("memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));")
+        Output("it->ob_spb.userLong = (long)it;")
+
+    def outputCleanupStructMembers(self):
+        ObjectDefinition.outputCleanupStructMembers(self)
+        Output("self->ob_spb.userLong = 0;")
+        Output("self->ob_thiscallback = 0;")
+        Output("Py_XDECREF(self->ob_completion);")
+        Output("Py_XDECREF(self->ob_interrupt);")
+
+    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_spb;", self.objecttype)
+        Output("return 1;")
+        OutRbrace()
+
 
 sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
 spbobject = SpbObjectDefinition('SPB', 'SPBObj', 'SPBPtr')