diff --git a/Modules/almodule.c b/Modules/almodule.c
index 93f26bd..691175e 100644
--- a/Modules/almodule.c
+++ b/Modules/almodule.c
@@ -1,5 +1,5 @@
 
-#define OLD_INTERFACE		/* define for pre-Irix 6 interface */
+#define OLD_INTERFACE           /* define for pre-Irix 6 interface */
 
 #include "Python.h"
 #include "stringobject.h"
@@ -19,9 +19,9 @@
 /* Declarations for objects of type port */
 
 typedef struct {
-	PyObject_HEAD
-	/* XXXX Add your own stuff here */
-	ALport port;
+    PyObject_HEAD
+    /* XXXX Add your own stuff here */
+    ALport port;
 } alpobject;
 
 static PyTypeObject Alptype;
@@ -33,9 +33,9 @@
 /* Declarations for objects of type config */
 
 typedef struct {
-	PyObject_HEAD
-	/* XXXX Add your own stuff here */
-	ALconfig config;
+    PyObject_HEAD
+    /* XXXX Add your own stuff here */
+    ALconfig config;
 } alcobject;
 
 static PyTypeObject Alctype;
@@ -44,199 +44,199 @@
 static void
 ErrorHandler(long code, const char *fmt, ...)
 {
-	va_list args;
-	char buf[128];
+    va_list args;
+    char buf[128];
 
-	va_start(args, fmt);
-	vsprintf(buf, fmt, args);
-	va_end(args);
-	PyErr_SetString(ErrorObject, buf);
+    va_start(args, fmt);
+    vsprintf(buf, fmt, args);
+    va_end(args);
+    PyErr_SetString(ErrorObject, buf);
 }
 
-#ifdef AL_NO_ELEM		/* IRIX 6 */
+#ifdef AL_NO_ELEM               /* IRIX 6 */
 
 static PyObject *
 param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)
 {
-	ALparamInfo info;
+    ALparamInfo info;
 
-	if (pinfo == NULL) {
-		pinfo = &info;
-		if (alGetParamInfo(resource, param, &info) < 0)
-			return NULL;
-	}
-	switch (pinfo->elementType) {
-	case AL_PTR_ELEM:
-		/* XXXX don't know how to handle this */
-	case AL_NO_ELEM:
-		Py_INCREF(Py_None);
-		return Py_None;
-	case AL_INT32_ELEM:
-	case AL_RESOURCE_ELEM:
-	case AL_ENUM_ELEM:
-		return PyInt_FromLong((long) value.i);
-	case AL_INT64_ELEM:
-		return PyLong_FromLongLong(value.ll);
-	case AL_FIXED_ELEM:
-		return PyFloat_FromDouble(alFixedToDouble(value.ll));
-	case AL_CHAR_ELEM:
-		if (value.ptr == NULL) {
-			Py_INCREF(Py_None);
-			return Py_None;
-		}
-		return PyString_FromString((char *) value.ptr);
-	default:
-		PyErr_SetString(ErrorObject, "unknown element type");
-		return NULL;
-	}
+    if (pinfo == NULL) {
+        pinfo = &info;
+        if (alGetParamInfo(resource, param, &info) < 0)
+            return NULL;
+    }
+    switch (pinfo->elementType) {
+    case AL_PTR_ELEM:
+        /* XXXX don't know how to handle this */
+    case AL_NO_ELEM:
+        Py_INCREF(Py_None);
+        return Py_None;
+    case AL_INT32_ELEM:
+    case AL_RESOURCE_ELEM:
+    case AL_ENUM_ELEM:
+        return PyInt_FromLong((long) value.i);
+    case AL_INT64_ELEM:
+        return PyLong_FromLongLong(value.ll);
+    case AL_FIXED_ELEM:
+        return PyFloat_FromDouble(alFixedToDouble(value.ll));
+    case AL_CHAR_ELEM:
+        if (value.ptr == NULL) {
+            Py_INCREF(Py_None);
+            return Py_None;
+        }
+        return PyString_FromString((char *) value.ptr);
+    default:
+        PyErr_SetString(ErrorObject, "unknown element type");
+        return NULL;
+    }
 }
 
 static int
 python2elem(PyObject *item, void *ptr, int elementType)
 {
-	switch (elementType) {
-	case AL_INT32_ELEM:
-	case AL_RESOURCE_ELEM:
-	case AL_ENUM_ELEM:
-		if (!PyInt_Check(item)) {
-			PyErr_BadArgument();
-			return -1;
-		}
-		*((int *) ptr) = PyInt_AsLong(item);
-		break;
-	case AL_INT64_ELEM:
-		if (PyInt_Check(item))
-			*((long long *) ptr) = PyInt_AsLong(item);
-		else if (PyLong_Check(item))
-			*((long long *) ptr) = PyLong_AsLongLong(item);
-		else {
-			PyErr_BadArgument();
-			return -1;
-		}
-		break;
-	case AL_FIXED_ELEM:
-		if (PyInt_Check(item))
-			*((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
-		else if (PyFloat_Check(item))
-			*((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
-		else {
-			PyErr_BadArgument();
-			return -1;
-		}
-		break;
-	default:
-		PyErr_SetString(ErrorObject, "unknown element type");
-		return -1;
-	}
-	return 0;
+    switch (elementType) {
+    case AL_INT32_ELEM:
+    case AL_RESOURCE_ELEM:
+    case AL_ENUM_ELEM:
+        if (!PyInt_Check(item)) {
+            PyErr_BadArgument();
+            return -1;
+        }
+        *((int *) ptr) = PyInt_AsLong(item);
+        break;
+    case AL_INT64_ELEM:
+        if (PyInt_Check(item))
+            *((long long *) ptr) = PyInt_AsLong(item);
+        else if (PyLong_Check(item))
+            *((long long *) ptr) = PyLong_AsLongLong(item);
+        else {
+            PyErr_BadArgument();
+            return -1;
+        }
+        break;
+    case AL_FIXED_ELEM:
+        if (PyInt_Check(item))
+            *((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
+        else if (PyFloat_Check(item))
+            *((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
+        else {
+            PyErr_BadArgument();
+            return -1;
+        }
+        break;
+    default:
+        PyErr_SetString(ErrorObject, "unknown element type");
+        return -1;
+    }
+    return 0;
 }
 
 static int
 python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)
 {
-	ALparamInfo info;
-	int i, stepsize;
-	PyObject *item;
+    ALparamInfo info;
+    int i, stepsize;
+    PyObject *item;
 
-	if (pinfo == NULL) {
-		pinfo = &info;
-		if (alGetParamInfo(resource, param->param, &info) < 0)
-			return -1;
-	}
-	switch (pinfo->valueType) {
-	case AL_STRING_VAL:
-		if (pinfo->elementType != AL_CHAR_ELEM) {
-			PyErr_SetString(ErrorObject, "unknown element type");
-			return -1;
-		}
-		if (!PyString_Check(value)) {
-			PyErr_BadArgument();
-			return -1;
-		}
-		param->value.ptr = PyString_AS_STRING(value);
-		param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
-		break;
-	case AL_SET_VAL:
-	case AL_VECTOR_VAL:
-		if (!PyList_Check(value) && !PyTuple_Check(value)) {
-			PyErr_BadArgument();
-			return -1;
-		}
-		switch (pinfo->elementType) {
-		case AL_INT32_ELEM:
-		case AL_RESOURCE_ELEM:
-		case AL_ENUM_ELEM:
-			param->sizeIn = PySequence_Size(value);
-			param->value.ptr = PyMem_NEW(int, param->sizeIn);
-			stepsize = sizeof(int);
-			break;
-		case AL_INT64_ELEM:
-		case AL_FIXED_ELEM:
-			param->sizeIn = PySequence_Size(value);
-			param->value.ptr = PyMem_NEW(long long, param->sizeIn);
-			stepsize = sizeof(long long);
-			break;
-		}
-		for (i = 0; i < param->sizeIn; i++) {
-			item = PySequence_GetItem(value, i);
-			if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
-				PyMem_DEL(param->value.ptr);
-				return -1;
-			}
-		}
-		break;
-	case AL_SCALAR_VAL:
-		switch (pinfo->elementType) {
-		case AL_INT32_ELEM:
-		case AL_RESOURCE_ELEM:
-		case AL_ENUM_ELEM:
-			return python2elem(value, (void *) &param->value.i,
-					   pinfo->elementType);
-		case AL_INT64_ELEM:
-		case AL_FIXED_ELEM:
-			return python2elem(value, (void *) &param->value.ll,
-					   pinfo->elementType);
-		default:
-			PyErr_SetString(ErrorObject, "unknown element type");
-			return -1;
-		}
-	}
-	return 0;
+    if (pinfo == NULL) {
+        pinfo = &info;
+        if (alGetParamInfo(resource, param->param, &info) < 0)
+            return -1;
+    }
+    switch (pinfo->valueType) {
+    case AL_STRING_VAL:
+        if (pinfo->elementType != AL_CHAR_ELEM) {
+            PyErr_SetString(ErrorObject, "unknown element type");
+            return -1;
+        }
+        if (!PyString_Check(value)) {
+            PyErr_BadArgument();
+            return -1;
+        }
+        param->value.ptr = PyString_AS_STRING(value);
+        param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
+        break;
+    case AL_SET_VAL:
+    case AL_VECTOR_VAL:
+        if (!PyList_Check(value) && !PyTuple_Check(value)) {
+            PyErr_BadArgument();
+            return -1;
+        }
+        switch (pinfo->elementType) {
+        case AL_INT32_ELEM:
+        case AL_RESOURCE_ELEM:
+        case AL_ENUM_ELEM:
+            param->sizeIn = PySequence_Size(value);
+            param->value.ptr = PyMem_NEW(int, param->sizeIn);
+            stepsize = sizeof(int);
+            break;
+        case AL_INT64_ELEM:
+        case AL_FIXED_ELEM:
+            param->sizeIn = PySequence_Size(value);
+            param->value.ptr = PyMem_NEW(long long, param->sizeIn);
+            stepsize = sizeof(long long);
+            break;
+        }
+        for (i = 0; i < param->sizeIn; i++) {
+            item = PySequence_GetItem(value, i);
+            if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
+                PyMem_DEL(param->value.ptr);
+                return -1;
+            }
+        }
+        break;
+    case AL_SCALAR_VAL:
+        switch (pinfo->elementType) {
+        case AL_INT32_ELEM:
+        case AL_RESOURCE_ELEM:
+        case AL_ENUM_ELEM:
+            return python2elem(value, (void *) &param->value.i,
+                               pinfo->elementType);
+        case AL_INT64_ELEM:
+        case AL_FIXED_ELEM:
+            return python2elem(value, (void *) &param->value.ll,
+                               pinfo->elementType);
+        default:
+            PyErr_SetString(ErrorObject, "unknown element type");
+            return -1;
+        }
+    }
+    return 0;
 }
 
 static int
 python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)
 {
-	PyObject *item;
-	ALpv *pvs;
-	ALparamInfo *pinfo;
-	int npvs, i;
+    PyObject *item;
+    ALpv *pvs;
+    ALparamInfo *pinfo;
+    int npvs, i;
 
-	npvs = PyList_Size(list);
-	pvs = PyMem_NEW(ALpv, npvs);
-	pinfo = PyMem_NEW(ALparamInfo, npvs);
-	for (i = 0; i < npvs; i++) {
-		item = PyList_GetItem(list, i);
-		if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
-			goto error;
-		if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
-		    alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
-			goto error;
-		if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
-			goto error;
-	}
+    npvs = PyList_Size(list);
+    pvs = PyMem_NEW(ALpv, npvs);
+    pinfo = PyMem_NEW(ALparamInfo, npvs);
+    for (i = 0; i < npvs; i++) {
+        item = PyList_GetItem(list, i);
+        if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
+            goto error;
+        if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
+            alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
+            goto error;
+        if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
+            goto error;
+    }
 
-	*pvsp = pvs;
-	*pinfop = pinfo;
-	return npvs;
+    *pvsp = pvs;
+    *pinfop = pinfo;
+    return npvs;
 
   error:
-	/* XXXX we should clean up everything */
-	if (pvs)
-		PyMem_DEL(pvs);
-	if (pinfo)
-		PyMem_DEL(pinfo);
-	return -1;
+    /* XXXX we should clean up everything */
+    if (pvs)
+        PyMem_DEL(pvs);
+    if (pinfo)
+        PyMem_DEL(pinfo);
+    return -1;
 }
 
 /* -------------------------------------------------------- */
@@ -245,30 +245,30 @@
 static PyObject *
 SetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig, int))
 {
-	int par;
+    int par;
 
-	if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
+        return NULL;
 
-	if ((*func)(self->config, par) == -1)
-		return NULL;
+    if ((*func)(self->config, par) == -1)
+        return NULL;
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 GetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig))
-{	
-	int par;
+{
+    int par;
 
-	if (!PyArg_ParseTuple(args, ":GetConfig"))
-		return NULL;
-	
-	if ((par = (*func)(self->config)) == -1)
-		return NULL;
+    if (!PyArg_ParseTuple(args, ":GetConfig"))
+        return NULL;
 
-	return PyInt_FromLong((long) par);
+    if ((par = (*func)(self->config)) == -1)
+        return NULL;
+
+    return PyInt_FromLong((long) par);
 }
 
 PyDoc_STRVAR(alc_SetWidth__doc__,
@@ -277,7 +277,7 @@
 static PyObject *
 alc_SetWidth(alcobject *self, PyObject *args)
 {
-	return SetConfig(self, args, alSetWidth);
+    return SetConfig(self, args, alSetWidth);
 }
 
 
@@ -287,7 +287,7 @@
 static PyObject *
 alc_GetWidth(alcobject *self, PyObject *args)
 {
-	return GetConfig(self, args, alGetWidth);
+    return GetConfig(self, args, alGetWidth);
 }
 
 
@@ -298,7 +298,7 @@
 static PyObject *
 alc_SetSampFmt(alcobject *self, PyObject *args)
 {
-	return SetConfig(self, args, alSetSampFmt);
+    return SetConfig(self, args, alSetSampFmt);
 }
 
 
@@ -309,7 +309,7 @@
 static PyObject *
 alc_GetSampFmt(alcobject *self, PyObject *args)
 {
-	return GetConfig(self, args, alGetSampFmt);
+    return GetConfig(self, args, alGetSampFmt);
 }
 
 
@@ -319,7 +319,7 @@
 static PyObject *
 alc_SetChannels(alcobject *self, PyObject *args)
 {
-	return SetConfig(self, args, alSetChannels);
+    return SetConfig(self, args, alSetChannels);
 }
 
 
@@ -329,7 +329,7 @@
 static PyObject *
 alc_GetChannels(alcobject *self, PyObject *args)
 {
-	return GetConfig(self, args, alGetChannels);
+    return GetConfig(self, args, alGetChannels);
 }
 
 
@@ -339,14 +339,14 @@
 static PyObject *
 alc_SetFloatMax(alcobject *self, PyObject *args)
 {
-	double maximum_value;
+    double maximum_value;
 
-	if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
-		return NULL;
-	if (alSetFloatMax(self->config, maximum_value) < 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
+        return NULL;
+    if (alSetFloatMax(self->config, maximum_value) < 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -356,13 +356,13 @@
 static PyObject *
 alc_GetFloatMax(alcobject *self, PyObject *args)
 {
-	double maximum_value;
+    double maximum_value;
 
-	if (!PyArg_ParseTuple(args, ":GetFloatMax"))
-		return NULL;
-	if ((maximum_value = alGetFloatMax(self->config)) == 0)
-		return NULL;
-	return PyFloat_FromDouble(maximum_value);
+    if (!PyArg_ParseTuple(args, ":GetFloatMax"))
+        return NULL;
+    if ((maximum_value = alGetFloatMax(self->config)) == 0)
+        return NULL;
+    return PyFloat_FromDouble(maximum_value);
 }
 
 
@@ -372,7 +372,7 @@
 static PyObject *
 alc_SetDevice(alcobject *self, PyObject *args)
 {
-	return SetConfig(self, args, alSetDevice);
+    return SetConfig(self, args, alSetDevice);
 }
 
 
@@ -382,7 +382,7 @@
 static PyObject *
 alc_GetDevice(alcobject *self, PyObject *args)
 {
-	return GetConfig(self, args, alGetDevice);
+    return GetConfig(self, args, alGetDevice);
 }
 
 
@@ -392,7 +392,7 @@
 static PyObject *
 alc_SetQueueSize(alcobject *self, PyObject *args)
 {
-	return SetConfig(self, args, alSetQueueSize);
+    return SetConfig(self, args, alSetQueueSize);
 }
 
 
@@ -402,7 +402,7 @@
 static PyObject *
 alc_GetQueueSize(alcobject *self, PyObject *args)
 {
-	return GetConfig(self, args, alGetQueueSize);
+    return GetConfig(self, args, alGetQueueSize);
 }
 
 #endif /* AL_NO_ELEM */
@@ -410,66 +410,66 @@
 static PyObject *
 setconfig(alcobject *self, PyObject *args, int (*func)(ALconfig, long))
 {
-	long par;
+    long par;
 
-	if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
+        return NULL;
 
-	if ((*func)(self->config, par) == -1)
-		return NULL;
+    if ((*func)(self->config, par) == -1)
+        return NULL;
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 getconfig(alcobject *self, PyObject *args, long (*func)(ALconfig))
-{	
-	long par;
+{
+    long par;
 
-	if (!PyArg_ParseTuple(args, ":GetConfig"))
-		return NULL;
-	
-	if ((par = (*func)(self->config)) == -1)
-		return NULL;
+    if (!PyArg_ParseTuple(args, ":GetConfig"))
+        return NULL;
 
-	return PyInt_FromLong((long) par);
+    if ((par = (*func)(self->config)) == -1)
+        return NULL;
+
+    return PyInt_FromLong((long) par);
 }
 
 static PyObject *
 alc_setqueuesize (alcobject *self, PyObject *args)
 {
-	return setconfig(self, args, ALsetqueuesize);
+    return setconfig(self, args, ALsetqueuesize);
 }
 
 static PyObject *
 alc_getqueuesize (alcobject *self, PyObject *args)
 {
-	return getconfig(self, args, ALgetqueuesize);
+    return getconfig(self, args, ALgetqueuesize);
 }
 
 static PyObject *
 alc_setwidth (alcobject *self, PyObject *args)
 {
-	return setconfig(self, args, ALsetwidth);
+    return setconfig(self, args, ALsetwidth);
 }
 
 static PyObject *
 alc_getwidth (alcobject *self, PyObject *args)
 {
-	return getconfig(self, args, ALgetwidth);	
+    return getconfig(self, args, ALgetwidth);
 }
 
 static PyObject *
 alc_getchannels (alcobject *self, PyObject *args)
 {
-	return getconfig(self, args, ALgetchannels);	
+    return getconfig(self, args, ALgetchannels);
 }
 
 static PyObject *
 alc_setchannels (alcobject *self, PyObject *args)
 {
-	return setconfig(self, args, ALsetchannels);
+    return setconfig(self, args, ALsetchannels);
 }
 
 #ifdef AL_405
@@ -477,70 +477,70 @@
 static PyObject *
 alc_getsampfmt (alcobject *self, PyObject *args)
 {
-	return getconfig(self, args, ALgetsampfmt);	
+    return getconfig(self, args, ALgetsampfmt);
 }
 
 static PyObject *
 alc_setsampfmt (alcobject *self, PyObject *args)
 {
-	return setconfig(self, args, ALsetsampfmt);
+    return setconfig(self, args, ALsetsampfmt);
 }
 
 static PyObject *
 alc_getfloatmax(alcobject *self, PyObject *args)
 {
-	double arg;
+    double arg;
 
-	if (!PyArg_ParseTuple(args, ":GetFloatMax"))
-		return 0;
-	if ((arg = ALgetfloatmax(self->config)) == 0)
-		return NULL;
-	return PyFloat_FromDouble(arg);
+    if (!PyArg_ParseTuple(args, ":GetFloatMax"))
+        return 0;
+    if ((arg = ALgetfloatmax(self->config)) == 0)
+        return NULL;
+    return PyFloat_FromDouble(arg);
 }
 
 static PyObject *
 alc_setfloatmax(alcobject *self, PyObject *args)
 {
-	double arg;
+    double arg;
 
-	if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
-		return 0;
-	if (ALsetfloatmax(self->config, arg) == -1)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
+        return 0;
+    if (ALsetfloatmax(self->config, arg) == -1)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif /* AL_405 */
-	
+
 static struct PyMethodDef alc_methods[] = {
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-	{"SetWidth",	(PyCFunction)alc_SetWidth,	METH_VARARGS,	alc_SetWidth__doc__},
-	{"GetWidth",	(PyCFunction)alc_GetWidth,	METH_VARARGS,	alc_GetWidth__doc__},
-	{"SetSampFmt",	(PyCFunction)alc_SetSampFmt,	METH_VARARGS,	alc_SetSampFmt__doc__},
-	{"GetSampFmt",	(PyCFunction)alc_GetSampFmt,	METH_VARARGS,	alc_GetSampFmt__doc__},
-	{"SetChannels",	(PyCFunction)alc_SetChannels,	METH_VARARGS,	alc_SetChannels__doc__},
-	{"GetChannels",	(PyCFunction)alc_GetChannels,	METH_VARARGS,	alc_GetChannels__doc__},
-	{"SetFloatMax",	(PyCFunction)alc_SetFloatMax,	METH_VARARGS,	alc_SetFloatMax__doc__},
-	{"GetFloatMax",	(PyCFunction)alc_GetFloatMax,	METH_VARARGS,	alc_GetFloatMax__doc__},
-	{"SetDevice",	(PyCFunction)alc_SetDevice,	METH_VARARGS,	alc_SetDevice__doc__},
-	{"GetDevice",	(PyCFunction)alc_GetDevice,	METH_VARARGS,	alc_GetDevice__doc__},
-	{"SetQueueSize",	(PyCFunction)alc_SetQueueSize,	METH_VARARGS,	alc_SetQueueSize__doc__},
-	{"GetQueueSize",	(PyCFunction)alc_GetQueueSize,	METH_VARARGS,	alc_GetQueueSize__doc__},
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+    {"SetWidth",        (PyCFunction)alc_SetWidth,      METH_VARARGS,   alc_SetWidth__doc__},
+    {"GetWidth",        (PyCFunction)alc_GetWidth,      METH_VARARGS,   alc_GetWidth__doc__},
+    {"SetSampFmt",      (PyCFunction)alc_SetSampFmt,    METH_VARARGS,   alc_SetSampFmt__doc__},
+    {"GetSampFmt",      (PyCFunction)alc_GetSampFmt,    METH_VARARGS,   alc_GetSampFmt__doc__},
+    {"SetChannels",     (PyCFunction)alc_SetChannels,   METH_VARARGS,   alc_SetChannels__doc__},
+    {"GetChannels",     (PyCFunction)alc_GetChannels,   METH_VARARGS,   alc_GetChannels__doc__},
+    {"SetFloatMax",     (PyCFunction)alc_SetFloatMax,   METH_VARARGS,   alc_SetFloatMax__doc__},
+    {"GetFloatMax",     (PyCFunction)alc_GetFloatMax,   METH_VARARGS,   alc_GetFloatMax__doc__},
+    {"SetDevice",       (PyCFunction)alc_SetDevice,     METH_VARARGS,   alc_SetDevice__doc__},
+    {"GetDevice",       (PyCFunction)alc_GetDevice,     METH_VARARGS,   alc_GetDevice__doc__},
+    {"SetQueueSize",            (PyCFunction)alc_SetQueueSize,  METH_VARARGS,   alc_SetQueueSize__doc__},
+    {"GetQueueSize",            (PyCFunction)alc_GetQueueSize,  METH_VARARGS,   alc_GetQueueSize__doc__},
 #endif /* AL_NO_ELEM */
-	{"getqueuesize",	(PyCFunction)alc_getqueuesize,	METH_VARARGS},
-	{"setqueuesize",	(PyCFunction)alc_setqueuesize,	METH_VARARGS},
-	{"getwidth",		(PyCFunction)alc_getwidth,	METH_VARARGS},
-	{"setwidth",		(PyCFunction)alc_setwidth,	METH_VARARGS},
-	{"getchannels",		(PyCFunction)alc_getchannels,	METH_VARARGS},
-	{"setchannels",		(PyCFunction)alc_setchannels,	METH_VARARGS},
+    {"getqueuesize",            (PyCFunction)alc_getqueuesize,  METH_VARARGS},
+    {"setqueuesize",            (PyCFunction)alc_setqueuesize,  METH_VARARGS},
+    {"getwidth",                (PyCFunction)alc_getwidth,      METH_VARARGS},
+    {"setwidth",                (PyCFunction)alc_setwidth,      METH_VARARGS},
+    {"getchannels",             (PyCFunction)alc_getchannels,   METH_VARARGS},
+    {"setchannels",             (PyCFunction)alc_setchannels,   METH_VARARGS},
 #ifdef AL_405
-	{"getsampfmt",		(PyCFunction)alc_getsampfmt,	METH_VARARGS},
-	{"setsampfmt",		(PyCFunction)alc_setsampfmt,	METH_VARARGS},
-	{"getfloatmax",		(PyCFunction)alc_getfloatmax,	METH_VARARGS},
-	{"setfloatmax",		(PyCFunction)alc_setfloatmax,	METH_VARARGS},
+    {"getsampfmt",              (PyCFunction)alc_getsampfmt,    METH_VARARGS},
+    {"setsampfmt",              (PyCFunction)alc_setsampfmt,    METH_VARARGS},
+    {"getfloatmax",             (PyCFunction)alc_getfloatmax,   METH_VARARGS},
+    {"setfloatmax",             (PyCFunction)alc_setfloatmax,   METH_VARARGS},
 #endif /* AL_405 */
 
-	{NULL,		NULL}		/* sentinel */
+    {NULL,              NULL}           /* sentinel */
 };
 
 /* ---------- */
@@ -549,67 +549,67 @@
 static PyObject *
 newalcobject(ALconfig config)
 {
-	alcobject *self;
-	
-	self = PyObject_New(alcobject, &Alctype);
-	if (self == NULL)
-		return NULL;
-	/* XXXX Add your own initializers here */
-	self->config = config;
-	return (PyObject *) self;
+    alcobject *self;
+
+    self = PyObject_New(alcobject, &Alctype);
+    if (self == NULL)
+        return NULL;
+    /* XXXX Add your own initializers here */
+    self->config = config;
+    return (PyObject *) self;
 }
 
 
 static void
 alc_dealloc(alcobject *self)
 {
-	/* XXXX Add your own cleanup code here */
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-	(void) alFreeConfig(self->config);	/* ignore errors */
+    /* XXXX Add your own cleanup code here */
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+    (void) alFreeConfig(self->config);          /* ignore errors */
 #else
-	(void) ALfreeconfig(self->config);	/* ignore errors */
+    (void) ALfreeconfig(self->config);          /* ignore errors */
 #endif
-	PyObject_Del(self);
+    PyObject_Del(self);
 }
 
 static PyObject *
 alc_getattr(alcobject *self, char *name)
 {
-	/* XXXX Add your own getattr code here */
-	return Py_FindMethod(alc_methods, (PyObject *)self, name);
+    /* XXXX Add your own getattr code here */
+    return Py_FindMethod(alc_methods, (PyObject *)self, name);
 }
 
 PyDoc_STRVAR(Alctype__doc__, "");
 
 static PyTypeObject Alctype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/*ob_size*/
-	"al.config",			/*tp_name*/
-	sizeof(alcobject),		/*tp_basicsize*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)alc_dealloc,	/*tp_dealloc*/
-	(printfunc)0,		/*tp_print*/
-	(getattrfunc)alc_getattr,	/*tp_getattr*/
-	(setattrfunc)0,	/*tp_setattr*/
-	(cmpfunc)0,		/*tp_compare*/
-	(reprfunc)0,		/*tp_repr*/
-	0,			/*tp_as_number*/
-	0,		/*tp_as_sequence*/
-	0,		/*tp_as_mapping*/
-	(hashfunc)0,		/*tp_hash*/
-	(ternaryfunc)0,		/*tp_call*/
-	(reprfunc)0,		/*tp_str*/
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,                                  /*ob_size*/
+    "al.config",                        /*tp_name*/
+    sizeof(alcobject),                  /*tp_basicsize*/
+    0,                                  /*tp_itemsize*/
+    /* methods */
+    (destructor)alc_dealloc,            /*tp_dealloc*/
+    (printfunc)0,               /*tp_print*/
+    (getattrfunc)alc_getattr,           /*tp_getattr*/
+    (setattrfunc)0,     /*tp_setattr*/
+    (cmpfunc)0,                 /*tp_compare*/
+    (reprfunc)0,                /*tp_repr*/
+    0,                          /*tp_as_number*/
+    0,                  /*tp_as_sequence*/
+    0,                  /*tp_as_mapping*/
+    (hashfunc)0,                /*tp_hash*/
+    (ternaryfunc)0,             /*tp_call*/
+    (reprfunc)0,                /*tp_str*/
 
-	/* Space for future expansion */
-	0L,0L,0L,0L,
-	Alctype__doc__ /* Documentation string */
+    /* Space for future expansion */
+    0L,0L,0L,0L,
+    Alctype__doc__ /* Documentation string */
 };
 
 /* End of code for config objects */
 /* ---------------------------------------------------------------- */
 
-#ifdef AL_NO_ELEM		/* IRIX 6 */
+#ifdef AL_NO_ELEM               /* IRIX 6 */
 
 PyDoc_STRVAR(alp_SetConfig__doc__,
 "alSetConfig: set the ALconfig of an audio ALport.");
@@ -617,13 +617,13 @@
 static PyObject *
 alp_SetConfig(alpobject *self, PyObject *args)
 {
-	alcobject *config;
-	if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
-		return NULL;
-	if (alSetConfig(self->port, config->config) < 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    alcobject *config;
+    if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
+        return NULL;
+    if (alSetConfig(self->port, config->config) < 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -633,12 +633,12 @@
 static PyObject *
 alp_GetConfig(alpobject *self, PyObject *args)
 {
-	ALconfig config;
-	if (!PyArg_ParseTuple(args, ":GetConfig"))
-		return NULL;
-	if ((config = alGetConfig(self->port)) == NULL)
-		return NULL;
-	return newalcobject(config);
+    ALconfig config;
+    if (!PyArg_ParseTuple(args, ":GetConfig"))
+        return NULL;
+    if ((config = alGetConfig(self->port)) == NULL)
+        return NULL;
+    return newalcobject(config);
 }
 
 
@@ -648,13 +648,13 @@
 static PyObject *
 alp_GetResource(alpobject *self, PyObject *args)
 {
-	int resource;
+    int resource;
 
-	if (!PyArg_ParseTuple(args, ":GetResource"))
-		return NULL;
-	if ((resource = alGetResource(self->port)) == 0)
-		return NULL;
-	return PyInt_FromLong((long) resource);
+    if (!PyArg_ParseTuple(args, ":GetResource"))
+        return NULL;
+    if ((resource = alGetResource(self->port)) == 0)
+        return NULL;
+    return PyInt_FromLong((long) resource);
 }
 
 
@@ -664,15 +664,15 @@
 static PyObject *
 alp_GetFD(alpobject *self, PyObject *args)
 {
-	int fd;
+    int fd;
 
-	if (!PyArg_ParseTuple(args, ":GetFD"))
-		return NULL;
+    if (!PyArg_ParseTuple(args, ":GetFD"))
+        return NULL;
 
-	if ((fd = alGetFD(self->port)) < 0)
-		return NULL;
+    if ((fd = alGetFD(self->port)) < 0)
+        return NULL;
 
-	return PyInt_FromLong((long) fd);
+    return PyInt_FromLong((long) fd);
 }
 
 
@@ -683,13 +683,13 @@
 static PyObject *
 alp_GetFilled(alpobject *self, PyObject *args)
 {
-	int filled;
+    int filled;
 
-	if (!PyArg_ParseTuple(args, ":GetFilled"))
-		return NULL;
-	if ((filled = alGetFilled(self->port)) < 0)
-		return NULL;
-	return PyInt_FromLong((long) filled);
+    if (!PyArg_ParseTuple(args, ":GetFilled"))
+        return NULL;
+    if ((filled = alGetFilled(self->port)) < 0)
+        return NULL;
+    return PyInt_FromLong((long) filled);
 }
 
 
@@ -700,13 +700,13 @@
 static PyObject *
 alp_GetFillable(alpobject *self, PyObject *args)
 {
-	int fillable;
+    int fillable;
 
-	if (!PyArg_ParseTuple(args, ":GetFillable"))
-		return NULL;
-	if ((fillable = alGetFillable(self->port)) < 0)
-		return NULL;
-	return PyInt_FromLong((long) fillable);
+    if (!PyArg_ParseTuple(args, ":GetFillable"))
+        return NULL;
+    if ((fillable = alGetFillable(self->port)) < 0)
+        return NULL;
+    return PyInt_FromLong((long) fillable);
 }
 
 
@@ -716,64 +716,64 @@
 static PyObject *
 alp_ReadFrames(alpobject *self, PyObject *args)
 {
-	int framecount;
-	PyObject *v;
-	int size;
-	int ch;
-	ALconfig c;
+    int framecount;
+    PyObject *v;
+    int size;
+    int ch;
+    ALconfig c;
 
-	if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
-		return NULL;
-	if (framecount < 0) {
-		PyErr_SetString(ErrorObject, "negative framecount");
-		return NULL;
-	}
-	c = alGetConfig(self->port);
-	switch (alGetSampFmt(c)) {
-	case AL_SAMPFMT_TWOSCOMP:
-		switch (alGetWidth(c)) {
-		case AL_SAMPLE_8:
-			size = 1;
-			break;
-		case AL_SAMPLE_16:
-			size = 2;
-			break;
-		case AL_SAMPLE_24:
-			size = 4;
-			break;
-		default:
-			PyErr_SetString(ErrorObject, "can't determine width");
-			alFreeConfig(c);
-			return NULL;
-		}
-		break;
-	case AL_SAMPFMT_FLOAT:
-		size = 4;
-		break;
-	case AL_SAMPFMT_DOUBLE:
-		size = 8;
-		break;
-	default:
-		PyErr_SetString(ErrorObject, "can't determine format");
-		alFreeConfig(c);
-		return NULL;
-	}
-	ch = alGetChannels(c);
-	alFreeConfig(c);
-	if (ch < 0) {
-		PyErr_SetString(ErrorObject, "can't determine # of channels");
-		return NULL;
-	}
-	size *= ch;
-	v = PyString_FromStringAndSize((char *) NULL, size * framecount);
-	if (v == NULL)
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
+        return NULL;
+    if (framecount < 0) {
+        PyErr_SetString(ErrorObject, "negative framecount");
+        return NULL;
+    }
+    c = alGetConfig(self->port);
+    switch (alGetSampFmt(c)) {
+    case AL_SAMPFMT_TWOSCOMP:
+        switch (alGetWidth(c)) {
+        case AL_SAMPLE_8:
+            size = 1;
+            break;
+        case AL_SAMPLE_16:
+            size = 2;
+            break;
+        case AL_SAMPLE_24:
+            size = 4;
+            break;
+        default:
+            PyErr_SetString(ErrorObject, "can't determine width");
+            alFreeConfig(c);
+            return NULL;
+        }
+        break;
+    case AL_SAMPFMT_FLOAT:
+        size = 4;
+        break;
+    case AL_SAMPFMT_DOUBLE:
+        size = 8;
+        break;
+    default:
+        PyErr_SetString(ErrorObject, "can't determine format");
+        alFreeConfig(c);
+        return NULL;
+    }
+    ch = alGetChannels(c);
+    alFreeConfig(c);
+    if (ch < 0) {
+        PyErr_SetString(ErrorObject, "can't determine # of channels");
+        return NULL;
+    }
+    size *= ch;
+    v = PyString_FromStringAndSize((char *) NULL, size * framecount);
+    if (v == NULL)
+        return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
+    Py_END_ALLOW_THREADS
 
-	return v;
+    return v;
 }
 
 
@@ -783,19 +783,19 @@
 static PyObject *
 alp_DiscardFrames(alpobject *self, PyObject *args)
 {
-	int framecount;
+    int framecount;
 
-	if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
+        return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	framecount = alDiscardFrames(self->port, framecount);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    framecount = alDiscardFrames(self->port, framecount);
+    Py_END_ALLOW_THREADS
 
-	if (framecount < 0)
-		return NULL;
+    if (framecount < 0)
+        return NULL;
 
-	return PyInt_FromLong((long) framecount);
+    return PyInt_FromLong((long) framecount);
 }
 
 
@@ -805,22 +805,22 @@
 static PyObject *
 alp_ZeroFrames(alpobject *self, PyObject *args)
 {
-	int framecount;
+    int framecount;
 
-	if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
+        return NULL;
 
-	if (framecount < 0) {
-		PyErr_SetString(ErrorObject, "negative framecount");
-		return NULL;
-	}
+    if (framecount < 0) {
+        PyErr_SetString(ErrorObject, "negative framecount");
+        return NULL;
+    }
 
-	Py_BEGIN_ALLOW_THREADS
-	alZeroFrames(self->port, framecount);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    alZeroFrames(self->port, framecount);
+    Py_END_ALLOW_THREADS
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -830,16 +830,16 @@
 static PyObject *
 alp_SetFillPoint(alpobject *self, PyObject *args)
 {
-	int fillpoint;
+    int fillpoint;
 
-	if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
+        return NULL;
 
-	if (alSetFillPoint(self->port, fillpoint) < 0)
-		return NULL;
+    if (alSetFillPoint(self->port, fillpoint) < 0)
+        return NULL;
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -849,15 +849,15 @@
 static PyObject *
 alp_GetFillPoint(alpobject *self, PyObject *args)
 {
-	int fillpoint;
+    int fillpoint;
 
-	if (!PyArg_ParseTuple(args, ":GetFillPoint"))
-		return NULL;
+    if (!PyArg_ParseTuple(args, ":GetFillPoint"))
+        return NULL;
 
-	if ((fillpoint = alGetFillPoint(self->port)) < 0)
-		return NULL;
+    if ((fillpoint = alGetFillPoint(self->port)) < 0)
+        return NULL;
 
-	return PyInt_FromLong((long) fillpoint);
+    return PyInt_FromLong((long) fillpoint);
 }
 
 
@@ -868,15 +868,15 @@
 static PyObject *
 alp_GetFrameNumber(alpobject *self, PyObject *args)
 {
-	stamp_t fnum;
+    stamp_t fnum;
 
-	if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
-		return NULL;
+    if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
+        return NULL;
 
-	if (alGetFrameNumber(self->port, &fnum) < 0)
-		return NULL;
+    if (alGetFrameNumber(self->port, &fnum) < 0)
+        return NULL;
 
-	return PyLong_FromLongLong((long long) fnum);
+    return PyLong_FromLongLong((long long) fnum);
 }
 
 
@@ -887,24 +887,24 @@
 static PyObject *
 alp_GetFrameTime(alpobject *self, PyObject *args)
 {
-	stamp_t fnum, time;
-	PyObject *ret, *v0, *v1;
+    stamp_t fnum, time;
+    PyObject *ret, *v0, *v1;
 
-	if (!PyArg_ParseTuple(args, ":GetFrameTime"))
-		return NULL;
-	if (alGetFrameTime(self->port, &fnum, &time) < 0)
-		return NULL;
-	v0 = PyLong_FromLongLong((long long) fnum);
-	v1 = PyLong_FromLongLong((long long) time);
-	if (PyErr_Occurred()) {
-		Py_XDECREF(v0);
-		Py_XDECREF(v1);
-		return NULL;
-	}
-	ret = PyTuple_Pack(2, v0, v1);
-	Py_DECREF(v0);
-	Py_DECREF(v1);
-	return ret;
+    if (!PyArg_ParseTuple(args, ":GetFrameTime"))
+        return NULL;
+    if (alGetFrameTime(self->port, &fnum, &time) < 0)
+        return NULL;
+    v0 = PyLong_FromLongLong((long long) fnum);
+    v1 = PyLong_FromLongLong((long long) time);
+    if (PyErr_Occurred()) {
+        Py_XDECREF(v0);
+        Py_XDECREF(v1);
+        return NULL;
+    }
+    ret = PyTuple_Pack(2, v0, v1);
+    Py_DECREF(v0);
+    Py_DECREF(v1);
+    return ret;
 }
 
 
@@ -914,62 +914,62 @@
 static PyObject *
 alp_WriteFrames(alpobject *self, PyObject *args)
 {
-	char *samples;
-	int length;
-	int size, ch;
-	ALconfig c;
+    char *samples;
+    int length;
+    int size, ch;
+    ALconfig c;
 
-	if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
-		return NULL;
-	c = alGetConfig(self->port);
-	switch (alGetSampFmt(c)) {
-	case AL_SAMPFMT_TWOSCOMP:
-		switch (alGetWidth(c)) {
-		case AL_SAMPLE_8:
-			size = 1;
-			break;
-		case AL_SAMPLE_16:
-			size = 2;
-			break;
-		case AL_SAMPLE_24:
-			size = 4;
-			break;
-		default:
-			PyErr_SetString(ErrorObject, "can't determine width");
-			alFreeConfig(c);
-			return NULL;
-		}
-		break;
-	case AL_SAMPFMT_FLOAT:
-		size = 4;
-		break;
-	case AL_SAMPFMT_DOUBLE:
-		size = 8;
-		break;
-	default:
-		PyErr_SetString(ErrorObject, "can't determine format");
-		alFreeConfig(c);
-		return NULL;
-	}
-	ch = alGetChannels(c);
-	alFreeConfig(c);
-	if (ch < 0) {
-		PyErr_SetString(ErrorObject, "can't determine # of channels");
-		return NULL;
-	}
-	size *= ch;
-	if (length % size != 0) {
-		PyErr_SetString(ErrorObject,
-				"buffer length not whole number of frames");
-		return NULL;
-	}
+    if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
+        return NULL;
+    c = alGetConfig(self->port);
+    switch (alGetSampFmt(c)) {
+    case AL_SAMPFMT_TWOSCOMP:
+        switch (alGetWidth(c)) {
+        case AL_SAMPLE_8:
+            size = 1;
+            break;
+        case AL_SAMPLE_16:
+            size = 2;
+            break;
+        case AL_SAMPLE_24:
+            size = 4;
+            break;
+        default:
+            PyErr_SetString(ErrorObject, "can't determine width");
+            alFreeConfig(c);
+            return NULL;
+        }
+        break;
+    case AL_SAMPFMT_FLOAT:
+        size = 4;
+        break;
+    case AL_SAMPFMT_DOUBLE:
+        size = 8;
+        break;
+    default:
+        PyErr_SetString(ErrorObject, "can't determine format");
+        alFreeConfig(c);
+        return NULL;
+    }
+    ch = alGetChannels(c);
+    alFreeConfig(c);
+    if (ch < 0) {
+        PyErr_SetString(ErrorObject, "can't determine # of channels");
+        return NULL;
+    }
+    size *= ch;
+    if (length % size != 0) {
+        PyErr_SetString(ErrorObject,
+                        "buffer length not whole number of frames");
+        return NULL;
+    }
 
-	Py_BEGIN_ALLOW_THREADS
-	alWriteFrames(self->port, (void *) samples, length / size);
-	Py_END_ALLOW_THREADS
+    Py_BEGIN_ALLOW_THREADS
+    alWriteFrames(self->port, (void *) samples, length / size);
+    Py_END_ALLOW_THREADS
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 
@@ -978,13 +978,13 @@
 static PyObject *
 alp_ClosePort(alpobject *self, PyObject *args)
 {
-	if (!PyArg_ParseTuple(args, ":ClosePort"))
-		return NULL;
-	if (alClosePort(self->port) < 0)
-		return NULL;
-	self->port = NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, ":ClosePort"))
+        return NULL;
+    if (alClosePort(self->port) < 0)
+        return NULL;
+    self->port = NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 #endif /* AL_NO_ELEM */
@@ -993,257 +993,257 @@
 static PyObject *
 alp_closeport(alpobject *self, PyObject *args)
 {
-	if (!PyArg_ParseTuple(args, ":ClosePort"))
-		return NULL;
-	if (ALcloseport(self->port) < 0)
-		return NULL;
-	self->port = NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, ":ClosePort"))
+        return NULL;
+    if (ALcloseport(self->port) < 0)
+        return NULL;
+    self->port = NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 alp_getfd(alpobject *self, PyObject *args)
 {
-	int fd;
+    int fd;
 
-	if (!PyArg_ParseTuple(args, ":GetFD"))
-		return NULL;
-	if ((fd = ALgetfd(self-> port)) == -1)
-		return NULL;
-	return PyInt_FromLong(fd);
+    if (!PyArg_ParseTuple(args, ":GetFD"))
+        return NULL;
+    if ((fd = ALgetfd(self-> port)) == -1)
+        return NULL;
+    return PyInt_FromLong(fd);
 }
 
 static PyObject *
 alp_getfilled(alpobject *self, PyObject *args)
 {
-	long count;
+    long count;
 
-	if (!PyArg_ParseTuple(args, ":GetFilled"))
-		return NULL;
-	if ((count = ALgetfilled(self-> port)) == -1)
-		return NULL;
-	return PyInt_FromLong(count);
+    if (!PyArg_ParseTuple(args, ":GetFilled"))
+        return NULL;
+    if ((count = ALgetfilled(self-> port)) == -1)
+        return NULL;
+    return PyInt_FromLong(count);
 }
 
 static PyObject *
 alp_getfillable(alpobject *self, PyObject *args)
 {
-	long count;
+    long count;
 
-	if (!PyArg_ParseTuple(args, ":GetFillable"))
-		return NULL;
-	if ((count = ALgetfillable(self-> port)) == -1)
-		return NULL;
-	return PyInt_FromLong (count);
+    if (!PyArg_ParseTuple(args, ":GetFillable"))
+        return NULL;
+    if ((count = ALgetfillable(self-> port)) == -1)
+        return NULL;
+    return PyInt_FromLong (count);
 }
 
 static PyObject *
 alp_readsamps(alpobject *self, PyObject *args)
 {
-	long count;
-	PyObject *v;
-	ALconfig c;
-	int width;
-	int ret;
+    long count;
+    PyObject *v;
+    ALconfig c;
+    int width;
+    int ret;
 
-	if (!PyArg_ParseTuple(args, "l:readsamps", &count))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "l:readsamps", &count))
+        return NULL;
 
-	if (count <= 0) {
-		PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
-		return NULL;
-	}
+    if (count <= 0) {
+        PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
+        return NULL;
+    }
 
-	c = ALgetconfig(self->port);
+    c = ALgetconfig(self->port);
 #ifdef AL_405
-	width = ALgetsampfmt(c);
-	if (width == AL_SAMPFMT_FLOAT)
-		width = sizeof(float);
-	else if (width == AL_SAMPFMT_DOUBLE)
-		width = sizeof(double);
-	else
-		width = ALgetwidth(c);
+    width = ALgetsampfmt(c);
+    if (width == AL_SAMPFMT_FLOAT)
+        width = sizeof(float);
+    else if (width == AL_SAMPFMT_DOUBLE)
+        width = sizeof(double);
+    else
+        width = ALgetwidth(c);
 #else
-	width = ALgetwidth(c);
+    width = ALgetwidth(c);
 #endif /* AL_405 */
-	ALfreeconfig(c);
-	v = PyString_FromStringAndSize((char *)NULL, width * count);
-	if (v == NULL)
-		return NULL;
+    ALfreeconfig(c);
+    v = PyString_FromStringAndSize((char *)NULL, width * count);
+    if (v == NULL)
+        return NULL;
 
-	Py_BEGIN_ALLOW_THREADS
-	ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
-	Py_END_ALLOW_THREADS
-	if (ret == -1) {
-		Py_DECREF(v);
-		return NULL;
-	}
+    Py_BEGIN_ALLOW_THREADS
+    ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        Py_DECREF(v);
+        return NULL;
+    }
 
-	return (v);
+    return (v);
 }
 
 static PyObject *
 alp_writesamps(alpobject *self, PyObject *args)
 {
-	char *buf;
-	int size, width;
-	ALconfig c;
-	int ret;
+    char *buf;
+    int size, width;
+    ALconfig c;
+    int ret;
 
-	if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
-		return NULL;
+    if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
+        return NULL;
 
-	c = ALgetconfig(self->port);
+    c = ALgetconfig(self->port);
 #ifdef AL_405
-	width = ALgetsampfmt(c);
-	if (width == AL_SAMPFMT_FLOAT)
-		width = sizeof(float);
-	else if (width == AL_SAMPFMT_DOUBLE)
-		width = sizeof(double);
-	else
-		width = ALgetwidth(c);
+    width = ALgetsampfmt(c);
+    if (width == AL_SAMPFMT_FLOAT)
+        width = sizeof(float);
+    else if (width == AL_SAMPFMT_DOUBLE)
+        width = sizeof(double);
+    else
+        width = ALgetwidth(c);
 #else
-	width = ALgetwidth(c);
+    width = ALgetwidth(c);
 #endif /* AL_405 */
-	ALfreeconfig(c);
-	Py_BEGIN_ALLOW_THREADS
-	ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
-	Py_END_ALLOW_THREADS
-	if (ret == -1)
-		return NULL;
+    ALfreeconfig(c);
+    Py_BEGIN_ALLOW_THREADS
+    ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
+    Py_END_ALLOW_THREADS
+    if (ret == -1)
+        return NULL;
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 alp_getfillpoint(alpobject *self, PyObject *args)
 {
-	long count;
+    long count;
 
-	if (!PyArg_ParseTuple(args, ":GetFillPoint"))
-		return NULL;
-	if ((count = ALgetfillpoint(self->port)) == -1)
-		return NULL;
-	return PyInt_FromLong(count);
+    if (!PyArg_ParseTuple(args, ":GetFillPoint"))
+        return NULL;
+    if ((count = ALgetfillpoint(self->port)) == -1)
+        return NULL;
+    return PyInt_FromLong(count);
 }
 
 static PyObject *
 alp_setfillpoint(alpobject *self, PyObject *args)
 {
-	long count;
+    long count;
 
-	if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
-		return NULL;
-	if (ALsetfillpoint(self->port, count) == -1)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
+        return NULL;
+    if (ALsetfillpoint(self->port, count) == -1)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 alp_setconfig(alpobject *self, PyObject *args)
 {
-	alcobject *config;
+    alcobject *config;
 
-	if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
-		return NULL;
-	if (ALsetconfig(self->port, config->config) == -1)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
+        return NULL;
+    if (ALsetconfig(self->port, config->config) == -1)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 alp_getconfig(alpobject *self, PyObject *args)
 {
-	ALconfig config;
+    ALconfig config;
 
-	if (!PyArg_ParseTuple(args, ":GetConfig"))
-		return NULL;
-	config = ALgetconfig(self->port);
-	if (config == NULL)
-		return NULL;
-	return newalcobject(config);
+    if (!PyArg_ParseTuple(args, ":GetConfig"))
+        return NULL;
+    config = ALgetconfig(self->port);
+    if (config == NULL)
+        return NULL;
+    return newalcobject(config);
 }
 
 #ifdef AL_405
 static PyObject *
 alp_getstatus(alpobject *self, PyObject *args)
 {
-	PyObject *list, *v;
-	long *PVbuffer;
-	long length;
-	int i;
-	
-	if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
-		return NULL;
-	length = PyList_Size(list);
-	PVbuffer = PyMem_NEW(long, length);
-	if (PVbuffer == NULL)
-		return PyErr_NoMemory();
-	for (i = 0; i < length; i++) {
-		v = PyList_GetItem(list, i);
-		if (!PyInt_Check(v)) {
-			PyMem_DEL(PVbuffer);
-			PyErr_BadArgument();
-			return NULL;
-		}
-		PVbuffer[i] = PyInt_AsLong(v);
-	}
+    PyObject *list, *v;
+    long *PVbuffer;
+    long length;
+    int i;
 
-	if (ALgetstatus(self->port, PVbuffer, length) == -1)
-		return NULL;
+    if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
+        return NULL;
+    length = PyList_Size(list);
+    PVbuffer = PyMem_NEW(long, length);
+    if (PVbuffer == NULL)
+        return PyErr_NoMemory();
+    for (i = 0; i < length; i++) {
+        v = PyList_GetItem(list, i);
+        if (!PyInt_Check(v)) {
+            PyMem_DEL(PVbuffer);
+            PyErr_BadArgument();
+            return NULL;
+        }
+        PVbuffer[i] = PyInt_AsLong(v);
+    }
 
-	for (i = 0; i < length; i++)
-		PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
+    if (ALgetstatus(self->port, PVbuffer, length) == -1)
+        return NULL;
 
-	PyMem_DEL(PVbuffer);
+    for (i = 0; i < length; i++)
+        PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyMem_DEL(PVbuffer);
+
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 #endif /* AL_405 */
 
 #endif /* OLD_INTERFACE */
 
 static struct PyMethodDef alp_methods[] = {
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-	{"SetConfig",	(PyCFunction)alp_SetConfig,	METH_VARARGS,	alp_SetConfig__doc__},
-	{"GetConfig",	(PyCFunction)alp_GetConfig,	METH_VARARGS,	alp_GetConfig__doc__},
-	{"GetResource",	(PyCFunction)alp_GetResource,	METH_VARARGS,	alp_GetResource__doc__},
-	{"GetFD",	(PyCFunction)alp_GetFD,	METH_VARARGS,	alp_GetFD__doc__},
-	{"GetFilled",	(PyCFunction)alp_GetFilled,	METH_VARARGS,	alp_GetFilled__doc__},
-	{"GetFillable",	(PyCFunction)alp_GetFillable,	METH_VARARGS,	alp_GetFillable__doc__},
-	{"ReadFrames",	(PyCFunction)alp_ReadFrames,	METH_VARARGS,	alp_ReadFrames__doc__},
-	{"DiscardFrames",	(PyCFunction)alp_DiscardFrames,	METH_VARARGS,	alp_DiscardFrames__doc__},
-	{"ZeroFrames",	(PyCFunction)alp_ZeroFrames,	METH_VARARGS,	alp_ZeroFrames__doc__},
-	{"SetFillPoint",	(PyCFunction)alp_SetFillPoint,	METH_VARARGS,	alp_SetFillPoint__doc__},
-	{"GetFillPoint",	(PyCFunction)alp_GetFillPoint,	METH_VARARGS,	alp_GetFillPoint__doc__},
-	{"GetFrameNumber",	(PyCFunction)alp_GetFrameNumber,	METH_VARARGS,	alp_GetFrameNumber__doc__},
-	{"GetFrameTime",	(PyCFunction)alp_GetFrameTime,	METH_VARARGS,	alp_GetFrameTime__doc__},
-	{"WriteFrames",	(PyCFunction)alp_WriteFrames,	METH_VARARGS,	alp_WriteFrames__doc__},
-	{"ClosePort",	(PyCFunction)alp_ClosePort,	METH_VARARGS,	alp_ClosePort__doc__},
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+    {"SetConfig",       (PyCFunction)alp_SetConfig,     METH_VARARGS,   alp_SetConfig__doc__},
+    {"GetConfig",       (PyCFunction)alp_GetConfig,     METH_VARARGS,   alp_GetConfig__doc__},
+    {"GetResource",     (PyCFunction)alp_GetResource,   METH_VARARGS,   alp_GetResource__doc__},
+    {"GetFD",           (PyCFunction)alp_GetFD, METH_VARARGS,   alp_GetFD__doc__},
+    {"GetFilled",       (PyCFunction)alp_GetFilled,     METH_VARARGS,   alp_GetFilled__doc__},
+    {"GetFillable",     (PyCFunction)alp_GetFillable,   METH_VARARGS,   alp_GetFillable__doc__},
+    {"ReadFrames",      (PyCFunction)alp_ReadFrames,    METH_VARARGS,   alp_ReadFrames__doc__},
+    {"DiscardFrames",           (PyCFunction)alp_DiscardFrames, METH_VARARGS,   alp_DiscardFrames__doc__},
+    {"ZeroFrames",      (PyCFunction)alp_ZeroFrames,    METH_VARARGS,   alp_ZeroFrames__doc__},
+    {"SetFillPoint",            (PyCFunction)alp_SetFillPoint,  METH_VARARGS,   alp_SetFillPoint__doc__},
+    {"GetFillPoint",            (PyCFunction)alp_GetFillPoint,  METH_VARARGS,   alp_GetFillPoint__doc__},
+    {"GetFrameNumber",          (PyCFunction)alp_GetFrameNumber,        METH_VARARGS,   alp_GetFrameNumber__doc__},
+    {"GetFrameTime",            (PyCFunction)alp_GetFrameTime,  METH_VARARGS,   alp_GetFrameTime__doc__},
+    {"WriteFrames",     (PyCFunction)alp_WriteFrames,   METH_VARARGS,   alp_WriteFrames__doc__},
+    {"ClosePort",       (PyCFunction)alp_ClosePort,     METH_VARARGS,   alp_ClosePort__doc__},
 #endif /* AL_NO_ELEM */
 #ifdef OLD_INTERFACE
-	{"closeport",		(PyCFunction)alp_closeport,	METH_VARARGS},
-	{"getfd",		(PyCFunction)alp_getfd,	METH_VARARGS},
-        {"fileno",		(PyCFunction)alp_getfd,	METH_VARARGS},
-	{"getfilled",		(PyCFunction)alp_getfilled,	METH_VARARGS},
-	{"getfillable",		(PyCFunction)alp_getfillable,	METH_VARARGS},
-	{"readsamps",		(PyCFunction)alp_readsamps,	METH_VARARGS},
-	{"writesamps",		(PyCFunction)alp_writesamps,	METH_VARARGS},
-	{"setfillpoint",	(PyCFunction)alp_setfillpoint,	METH_VARARGS},
-	{"getfillpoint",	(PyCFunction)alp_getfillpoint,	METH_VARARGS},
-	{"setconfig",		(PyCFunction)alp_setconfig,	METH_VARARGS},
-	{"getconfig",		(PyCFunction)alp_getconfig,	METH_VARARGS},
+    {"closeport",               (PyCFunction)alp_closeport,     METH_VARARGS},
+    {"getfd",                   (PyCFunction)alp_getfd, METH_VARARGS},
+    {"fileno",                  (PyCFunction)alp_getfd, METH_VARARGS},
+    {"getfilled",               (PyCFunction)alp_getfilled,     METH_VARARGS},
+    {"getfillable",             (PyCFunction)alp_getfillable,   METH_VARARGS},
+    {"readsamps",               (PyCFunction)alp_readsamps,     METH_VARARGS},
+    {"writesamps",              (PyCFunction)alp_writesamps,    METH_VARARGS},
+    {"setfillpoint",            (PyCFunction)alp_setfillpoint,  METH_VARARGS},
+    {"getfillpoint",            (PyCFunction)alp_getfillpoint,  METH_VARARGS},
+    {"setconfig",               (PyCFunction)alp_setconfig,     METH_VARARGS},
+    {"getconfig",               (PyCFunction)alp_getconfig,     METH_VARARGS},
 #ifdef AL_405
-	{"getstatus",		(PyCFunction)alp_getstatus,	METH_VARARGS},
-#endif /* AL_405 */	    
+    {"getstatus",               (PyCFunction)alp_getstatus,     METH_VARARGS},
+#endif /* AL_405 */
 #endif /* OLD_INTERFACE */
- 
-	{NULL,		NULL}		/* sentinel */
+
+    {NULL,              NULL}           /* sentinel */
 };
 
 /* ---------- */
@@ -1252,74 +1252,74 @@
 static PyObject *
 newalpobject(ALport port)
 {
-	alpobject *self;
-	
-	self = PyObject_New(alpobject, &Alptype);
-	if (self == NULL)
-		return NULL;
-	/* XXXX Add your own initializers here */
-	self->port = port;
-	return (PyObject *) self;
+    alpobject *self;
+
+    self = PyObject_New(alpobject, &Alptype);
+    if (self == NULL)
+        return NULL;
+    /* XXXX Add your own initializers here */
+    self->port = port;
+    return (PyObject *) self;
 }
 
 
 static void
 alp_dealloc(alpobject *self)
 {
-	/* XXXX Add your own cleanup code here */
-	if (self->port) {
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-		alClosePort(self->port);
+    /* XXXX Add your own cleanup code here */
+    if (self->port) {
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+        alClosePort(self->port);
 #else
-		ALcloseport(self->port);
+        ALcloseport(self->port);
 #endif
-	}
-	PyObject_Del(self);
+    }
+    PyObject_Del(self);
 }
 
 static PyObject *
 alp_getattr(alpobject *self, char *name)
 {
-	/* XXXX Add your own getattr code here */
-	if (self->port == NULL) {
-		PyErr_SetString(ErrorObject, "port already closed");
-		return NULL;
-	}
-	return Py_FindMethod(alp_methods, (PyObject *)self, name);
+    /* XXXX Add your own getattr code here */
+    if (self->port == NULL) {
+        PyErr_SetString(ErrorObject, "port already closed");
+        return NULL;
+    }
+    return Py_FindMethod(alp_methods, (PyObject *)self, name);
 }
 
 PyDoc_STRVAR(Alptype__doc__, "");
 
 static PyTypeObject Alptype = {
-	PyObject_HEAD_INIT(&PyType_Type)
-	0,				/*ob_size*/
-	"al.port",			/*tp_name*/
-	sizeof(alpobject),		/*tp_basicsize*/
-	0,				/*tp_itemsize*/
-	/* methods */
-	(destructor)alp_dealloc,	/*tp_dealloc*/
-	(printfunc)0,		/*tp_print*/
-	(getattrfunc)alp_getattr,	/*tp_getattr*/
-	(setattrfunc)0,	/*tp_setattr*/
-	(cmpfunc)0,		/*tp_compare*/
-	(reprfunc)0,		/*tp_repr*/
-	0,			/*tp_as_number*/
-	0,		/*tp_as_sequence*/
-	0,		/*tp_as_mapping*/
-	(hashfunc)0,		/*tp_hash*/
-	(ternaryfunc)0,		/*tp_call*/
-	(reprfunc)0,		/*tp_str*/
+    PyObject_HEAD_INIT(&PyType_Type)
+    0,                                  /*ob_size*/
+    "al.port",                          /*tp_name*/
+    sizeof(alpobject),                  /*tp_basicsize*/
+    0,                                  /*tp_itemsize*/
+    /* methods */
+    (destructor)alp_dealloc,            /*tp_dealloc*/
+    (printfunc)0,               /*tp_print*/
+    (getattrfunc)alp_getattr,           /*tp_getattr*/
+    (setattrfunc)0,     /*tp_setattr*/
+    (cmpfunc)0,                 /*tp_compare*/
+    (reprfunc)0,                /*tp_repr*/
+    0,                          /*tp_as_number*/
+    0,                  /*tp_as_sequence*/
+    0,                  /*tp_as_mapping*/
+    (hashfunc)0,                /*tp_hash*/
+    (ternaryfunc)0,             /*tp_call*/
+    (reprfunc)0,                /*tp_str*/
 
-	/* Space for future expansion */
-	0L,0L,0L,0L,
-	Alptype__doc__ /* Documentation string */
+    /* Space for future expansion */
+    0L,0L,0L,0L,
+    Alptype__doc__ /* Documentation string */
 };
 
 /* End of code for port objects */
 /* -------------------------------------------------------- */
 
 
-#ifdef AL_NO_ELEM		/* IRIX 6 */
+#ifdef AL_NO_ELEM               /* IRIX 6 */
 
 PyDoc_STRVAR(al_NewConfig__doc__,
 "alNewConfig: create and initialize an audio ALconfig structure.");
@@ -1327,13 +1327,13 @@
 static PyObject *
 al_NewConfig(PyObject *self, PyObject *args)
 {
-	ALconfig config;
+    ALconfig config;
 
-	if (!PyArg_ParseTuple(args, ":NewConfig"))
-		return NULL;
-	if ((config = alNewConfig()) == NULL)
-		return NULL;
-	return newalcobject(config);
+    if (!PyArg_ParseTuple(args, ":NewConfig"))
+        return NULL;
+    if ((config = alNewConfig()) == NULL)
+        return NULL;
+    return newalcobject(config);
 }
 
 PyDoc_STRVAR(al_OpenPort__doc__,
@@ -1342,15 +1342,15 @@
 static PyObject *
 al_OpenPort(PyObject *self, PyObject *args)
 {
-	ALport port;
-	char *name, *dir;
-	alcobject *config = NULL;
+    ALport port;
+    char *name, *dir;
+    alcobject *config = NULL;
 
-	if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
-		return NULL;
-	if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
-		return NULL;
-	return newalpobject(port);
+    if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
+        return NULL;
+    if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
+        return NULL;
+    return newalpobject(port);
 }
 
 PyDoc_STRVAR(al_Connect__doc__,
@@ -1359,37 +1359,37 @@
 static PyObject *
 al_Connect(PyObject *self, PyObject *args)
 {
-	int source, dest, nprops = 0, id, i;
-	ALpv *props = NULL;
-	ALparamInfo *propinfo = NULL;
-	PyObject *propobj = NULL;
+    int source, dest, nprops = 0, id, i;
+    ALpv *props = NULL;
+    ALparamInfo *propinfo = NULL;
+    PyObject *propobj = NULL;
 
-	if (!PyArg_ParseTuple(args, "ii|O!:Connect", &source, &dest, &PyList_Type, &propobj))
-		return NULL;
-	if (propobj != NULL) {
-		nprops = python2params(source, dest, propobj, &props, &propinfo);
-		if (nprops < 0)
-			return NULL;
-	}
+    if (!PyArg_ParseTuple(args, "ii|O!:Connect", &source, &dest, &PyList_Type, &propobj))
+        return NULL;
+    if (propobj != NULL) {
+        nprops = python2params(source, dest, propobj, &props, &propinfo);
+        if (nprops < 0)
+            return NULL;
+    }
 
-	id = alConnect(source, dest, props, nprops);
+    id = alConnect(source, dest, props, nprops);
 
-	if (props) {
-		for (i = 0; i < nprops; i++) {
-			switch (propinfo[i].valueType) {
-			case AL_SET_VAL:
-			case AL_VECTOR_VAL:
-				PyMem_DEL(props[i].value.ptr);
-				break;
-			}
-		}
-		PyMem_DEL(props);
-		PyMem_DEL(propinfo);
-	}
+    if (props) {
+        for (i = 0; i < nprops; i++) {
+            switch (propinfo[i].valueType) {
+            case AL_SET_VAL:
+            case AL_VECTOR_VAL:
+                PyMem_DEL(props[i].value.ptr);
+                break;
+            }
+        }
+        PyMem_DEL(props);
+        PyMem_DEL(propinfo);
+    }
 
-	if (id < 0)
-		return NULL;
-	return PyInt_FromLong((long) id);
+    if (id < 0)
+        return NULL;
+    return PyInt_FromLong((long) id);
 }
 
 PyDoc_STRVAR(al_Disconnect__doc__,
@@ -1398,14 +1398,14 @@
 static PyObject *
 al_Disconnect(PyObject *self, PyObject *args)
 {
-	int res;
+    int res;
 
-	if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
-		return NULL;
-	if (alDisconnect(res) < 0)
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
+        return NULL;
+    if (alDisconnect(res) < 0)
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 PyDoc_STRVAR(al_GetParams__doc__,
@@ -1414,143 +1414,143 @@
 static PyObject *
 al_GetParams(PyObject *self, PyObject *args)
 {
-	int resource;
-	PyObject *pvslist, *item = NULL, *v = NULL;
-	ALpv *pvs;
-	int i, j, npvs;
-	ALparamInfo *pinfo;
+    int resource;
+    PyObject *pvslist, *item = NULL, *v = NULL;
+    ALpv *pvs;
+    int i, j, npvs;
+    ALparamInfo *pinfo;
 
-	if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
-		return NULL;
-	npvs = PyList_Size(pvslist);
-	pvs = PyMem_NEW(ALpv, npvs);
-	pinfo = PyMem_NEW(ALparamInfo, npvs);
-	for (i = 0; i < npvs; i++) {
-		item = PyList_GetItem(pvslist, i);
-		if (!PyInt_Check(item)) {
-			item = NULL;
-			PyErr_SetString(ErrorObject, "list of integers expected");
-			goto error;
-		}
-		pvs[i].param = (int) PyInt_AsLong(item);
-		item = NULL;	/* not needed anymore */
-		if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
-			goto error;
-		switch (pinfo[i].valueType) {
-		case AL_NO_VAL:
-			break;
-		case AL_MATRIX_VAL:
-			pinfo[i].maxElems *= pinfo[i].maxElems2;
-			/* fall through */
-		case AL_STRING_VAL:
-		case AL_SET_VAL:
-		case AL_VECTOR_VAL:
-			switch (pinfo[i].elementType) {
-			case AL_INT32_ELEM:
-			case AL_RESOURCE_ELEM:
-			case AL_ENUM_ELEM:
-				pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
-				pvs[i].sizeIn = pinfo[i].maxElems;
-				break;
-			case AL_INT64_ELEM:
-			case AL_FIXED_ELEM:
-				pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
-				pvs[i].sizeIn = pinfo[i].maxElems;
-				break;
-			case AL_CHAR_ELEM:
-				pvs[i].value.ptr = PyMem_NEW(char, 32);
-				pvs[i].sizeIn = 32;
-				break;
-			case AL_NO_ELEM:
-			case AL_PTR_ELEM:
-			default:
-				PyErr_SetString(ErrorObject, "internal error");
-				goto error;
-			}
-			break;
-		case AL_SCALAR_VAL:
-			break;
-		default:
-			PyErr_SetString(ErrorObject, "internal error");
-			goto error;
-		}
-		if (pinfo[i].valueType == AL_MATRIX_VAL) {
-			pinfo[i].maxElems /= pinfo[i].maxElems2;
-			pvs[i].sizeIn /= pinfo[i].maxElems2;
-			pvs[i].size2In = pinfo[i].maxElems2;
-		}
-	}
-	if (alGetParams(resource, pvs, npvs) < 0)
-		goto error;
-	if (!(v = PyList_New(npvs)))
-		goto error;
-	for (i = 0; i < npvs; i++) {
-		if (pvs[i].sizeOut < 0) {
-			char buf[32];
-			PyOS_snprintf(buf, sizeof(buf),
-				      "problem with param %d", i);
-			PyErr_SetString(ErrorObject, buf);
-			goto error;
-		}
-		switch (pinfo[i].valueType) {
-		case AL_NO_VAL:
-			item = Py_None;
-			Py_INCREF(item);
-			break;
-		case AL_STRING_VAL:
-			item = PyString_FromString(pvs[i].value.ptr);
-			PyMem_DEL(pvs[i].value.ptr);
-			break;
-		case AL_MATRIX_VAL:
-			/* XXXX this is not right */
-			pvs[i].sizeOut *= pvs[i].size2Out;
-			/* fall through */
-		case AL_SET_VAL:
-		case AL_VECTOR_VAL:
-			item = PyList_New(pvs[i].sizeOut);
-			for (j = 0; j < pvs[i].sizeOut; j++) {
-				switch (pinfo[i].elementType) {
-				case AL_INT32_ELEM:
-				case AL_RESOURCE_ELEM:
-				case AL_ENUM_ELEM:
-					PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
-					break;
-				case AL_INT64_ELEM:
-					PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
-					break;
-				case AL_FIXED_ELEM:
-					PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
-					break;
-				default:
-					PyErr_SetString(ErrorObject, "internal error");
-					goto error;
-				}
-			}
-			PyMem_DEL(pvs[i].value.ptr);
-			break;
-		case AL_SCALAR_VAL:
-			item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
-			break;
-		}
-		if (PyErr_Occurred() ||
-		    PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
-						       item)) < 0 ||
-		    PyErr_Occurred())
-			goto error;
-		Py_DECREF(item);
-	}
-	PyMem_DEL(pvs);
-	PyMem_DEL(pinfo);
-	return v;
+    if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
+        return NULL;
+    npvs = PyList_Size(pvslist);
+    pvs = PyMem_NEW(ALpv, npvs);
+    pinfo = PyMem_NEW(ALparamInfo, npvs);
+    for (i = 0; i < npvs; i++) {
+        item = PyList_GetItem(pvslist, i);
+        if (!PyInt_Check(item)) {
+            item = NULL;
+            PyErr_SetString(ErrorObject, "list of integers expected");
+            goto error;
+        }
+        pvs[i].param = (int) PyInt_AsLong(item);
+        item = NULL;            /* not needed anymore */
+        if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
+            goto error;
+        switch (pinfo[i].valueType) {
+        case AL_NO_VAL:
+            break;
+        case AL_MATRIX_VAL:
+            pinfo[i].maxElems *= pinfo[i].maxElems2;
+            /* fall through */
+        case AL_STRING_VAL:
+        case AL_SET_VAL:
+        case AL_VECTOR_VAL:
+            switch (pinfo[i].elementType) {
+            case AL_INT32_ELEM:
+            case AL_RESOURCE_ELEM:
+            case AL_ENUM_ELEM:
+                pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
+                pvs[i].sizeIn = pinfo[i].maxElems;
+                break;
+            case AL_INT64_ELEM:
+            case AL_FIXED_ELEM:
+                pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
+                pvs[i].sizeIn = pinfo[i].maxElems;
+                break;
+            case AL_CHAR_ELEM:
+                pvs[i].value.ptr = PyMem_NEW(char, 32);
+                pvs[i].sizeIn = 32;
+                break;
+            case AL_NO_ELEM:
+            case AL_PTR_ELEM:
+            default:
+                PyErr_SetString(ErrorObject, "internal error");
+                goto error;
+            }
+            break;
+        case AL_SCALAR_VAL:
+            break;
+        default:
+            PyErr_SetString(ErrorObject, "internal error");
+            goto error;
+        }
+        if (pinfo[i].valueType == AL_MATRIX_VAL) {
+            pinfo[i].maxElems /= pinfo[i].maxElems2;
+            pvs[i].sizeIn /= pinfo[i].maxElems2;
+            pvs[i].size2In = pinfo[i].maxElems2;
+        }
+    }
+    if (alGetParams(resource, pvs, npvs) < 0)
+        goto error;
+    if (!(v = PyList_New(npvs)))
+        goto error;
+    for (i = 0; i < npvs; i++) {
+        if (pvs[i].sizeOut < 0) {
+            char buf[32];
+            PyOS_snprintf(buf, sizeof(buf),
+                          "problem with param %d", i);
+            PyErr_SetString(ErrorObject, buf);
+            goto error;
+        }
+        switch (pinfo[i].valueType) {
+        case AL_NO_VAL:
+            item = Py_None;
+            Py_INCREF(item);
+            break;
+        case AL_STRING_VAL:
+            item = PyString_FromString(pvs[i].value.ptr);
+            PyMem_DEL(pvs[i].value.ptr);
+            break;
+        case AL_MATRIX_VAL:
+            /* XXXX this is not right */
+            pvs[i].sizeOut *= pvs[i].size2Out;
+            /* fall through */
+        case AL_SET_VAL:
+        case AL_VECTOR_VAL:
+            item = PyList_New(pvs[i].sizeOut);
+            for (j = 0; j < pvs[i].sizeOut; j++) {
+                switch (pinfo[i].elementType) {
+                case AL_INT32_ELEM:
+                case AL_RESOURCE_ELEM:
+                case AL_ENUM_ELEM:
+                    PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
+                    break;
+                case AL_INT64_ELEM:
+                    PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
+                    break;
+                case AL_FIXED_ELEM:
+                    PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
+                    break;
+                default:
+                    PyErr_SetString(ErrorObject, "internal error");
+                    goto error;
+                }
+            }
+            PyMem_DEL(pvs[i].value.ptr);
+            break;
+        case AL_SCALAR_VAL:
+            item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
+            break;
+        }
+        if (PyErr_Occurred() ||
+            PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
+                                               item)) < 0 ||
+            PyErr_Occurred())
+            goto error;
+        Py_DECREF(item);
+    }
+    PyMem_DEL(pvs);
+    PyMem_DEL(pinfo);
+    return v;
 
   error:
-	Py_XDECREF(v);
-	Py_XDECREF(item);
-	if (pvs)
-		PyMem_DEL(pvs);
-	if (pinfo)
-		PyMem_DEL(pinfo);
-	return NULL;
+    Py_XDECREF(v);
+    Py_XDECREF(item);
+    if (pvs)
+        PyMem_DEL(pvs);
+    if (pinfo)
+        PyMem_DEL(pinfo);
+    return NULL;
 }
 
 PyDoc_STRVAR(al_SetParams__doc__,
@@ -1559,43 +1559,43 @@
 static PyObject *
 al_SetParams(PyObject *self, PyObject *args)
 {
-	int resource;
-	PyObject *pvslist;
-	ALpv *pvs;
-	ALparamInfo *pinfo;
-	int npvs, i;
+    int resource;
+    PyObject *pvslist;
+    ALpv *pvs;
+    ALparamInfo *pinfo;
+    int npvs, i;
 
-	if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
-		return NULL;
-	npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
-	if (npvs < 0)
-		return NULL;
+    if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
+        return NULL;
+    npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
+    if (npvs < 0)
+        return NULL;
 
-	if (alSetParams(resource, pvs, npvs) < 0)
-		goto error;
+    if (alSetParams(resource, pvs, npvs) < 0)
+        goto error;
 
-	/* cleanup */
-	for (i = 0; i < npvs; i++) {
-		switch (pinfo[i].valueType) {
-		case AL_SET_VAL:
-		case AL_VECTOR_VAL:
-			PyMem_DEL(pvs[i].value.ptr);
-			break;
-		}
-	}
-	PyMem_DEL(pvs);
-	PyMem_DEL(pinfo);
+    /* cleanup */
+    for (i = 0; i < npvs; i++) {
+        switch (pinfo[i].valueType) {
+        case AL_SET_VAL:
+        case AL_VECTOR_VAL:
+            PyMem_DEL(pvs[i].value.ptr);
+            break;
+        }
+    }
+    PyMem_DEL(pvs);
+    PyMem_DEL(pinfo);
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    Py_INCREF(Py_None);
+    return Py_None;
 
   error:
-	/* XXXX we should clean up everything */
-	if (pvs)
-		PyMem_DEL(pvs);
-	if (pinfo)
-		PyMem_DEL(pinfo);
-	return NULL;
+    /* XXXX we should clean up everything */
+    if (pvs)
+        PyMem_DEL(pvs);
+    if (pinfo)
+        PyMem_DEL(pinfo);
+    return NULL;
 }
 
 PyDoc_STRVAR(al_QueryValues__doc__,
@@ -1604,79 +1604,79 @@
 static PyObject *
 al_QueryValues(PyObject *self, PyObject *args)
 {
-	int resource, param;
-	ALvalue *return_set = NULL;
-	int setsize = 32, qualsize = 0, nvals, i;
-	ALpv *quals = NULL;
-	ALparamInfo pinfo;
-	ALparamInfo *qualinfo = NULL;
-	PyObject *qualobj = NULL;
-	PyObject *res = NULL, *item;
+    int resource, param;
+    ALvalue *return_set = NULL;
+    int setsize = 32, qualsize = 0, nvals, i;
+    ALpv *quals = NULL;
+    ALparamInfo pinfo;
+    ALparamInfo *qualinfo = NULL;
+    PyObject *qualobj = NULL;
+    PyObject *res = NULL, *item;
 
-	if (!PyArg_ParseTuple(args, "ii|O!:QueryValues", &resource, &param,
-			      &PyList_Type, &qualobj))
-		return NULL;
-	if (qualobj != NULL) {
-		qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
-		if (qualsize < 0)
-			return NULL;
-	}
-	setsize = 32;
-	return_set = PyMem_NEW(ALvalue, setsize);
-	if (return_set == NULL) {
-		PyErr_NoMemory();
-		goto cleanup;
-	}
+    if (!PyArg_ParseTuple(args, "ii|O!:QueryValues", &resource, &param,
+                          &PyList_Type, &qualobj))
+        return NULL;
+    if (qualobj != NULL) {
+        qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
+        if (qualsize < 0)
+            return NULL;
+    }
+    setsize = 32;
+    return_set = PyMem_NEW(ALvalue, setsize);
+    if (return_set == NULL) {
+        PyErr_NoMemory();
+        goto cleanup;
+    }
 
   retry:
-	nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
-	if (nvals < 0)
-		goto cleanup;
-	if (nvals > setsize) {
-		ALvalue *old_return_set = return_set;
-		setsize = nvals;
-		PyMem_RESIZE(return_set, ALvalue, setsize);
-		if (return_set == NULL) {
-			return_set = old_return_set;
-			PyErr_NoMemory();
-			goto cleanup;
-		}
-		goto retry;
-	}
+    nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
+    if (nvals < 0)
+        goto cleanup;
+    if (nvals > setsize) {
+        ALvalue *old_return_set = return_set;
+        setsize = nvals;
+        PyMem_RESIZE(return_set, ALvalue, setsize);
+        if (return_set == NULL) {
+            return_set = old_return_set;
+            PyErr_NoMemory();
+            goto cleanup;
+        }
+        goto retry;
+    }
 
-	if (alGetParamInfo(resource, param, &pinfo) < 0)
-		goto cleanup;
+    if (alGetParamInfo(resource, param, &pinfo) < 0)
+        goto cleanup;
 
-	res = PyList_New(nvals);
-	if (res == NULL)
-		goto cleanup;
-	for (i = 0; i < nvals; i++) {
-		item = param2python(resource, param, return_set[i], &pinfo);
-		if (item == NULL ||
-		    PyList_SetItem(res, i, item) < 0) {
-			Py_DECREF(res);
-			res = NULL;
-			goto cleanup;
-		}
-	}
+    res = PyList_New(nvals);
+    if (res == NULL)
+        goto cleanup;
+    for (i = 0; i < nvals; i++) {
+        item = param2python(resource, param, return_set[i], &pinfo);
+        if (item == NULL ||
+            PyList_SetItem(res, i, item) < 0) {
+            Py_DECREF(res);
+            res = NULL;
+            goto cleanup;
+        }
+    }
 
   cleanup:
-	if (return_set)
-		PyMem_DEL(return_set);
-	if (quals) {
-		for (i = 0; i < qualsize; i++) {
-			switch (qualinfo[i].valueType) {
-			case AL_SET_VAL:
-			case AL_VECTOR_VAL:
-				PyMem_DEL(quals[i].value.ptr);
-				break;
-			}
-		}
-		PyMem_DEL(quals);
-		PyMem_DEL(qualinfo);
-	}
+    if (return_set)
+        PyMem_DEL(return_set);
+    if (quals) {
+        for (i = 0; i < qualsize; i++) {
+            switch (qualinfo[i].valueType) {
+            case AL_SET_VAL:
+            case AL_VECTOR_VAL:
+                PyMem_DEL(quals[i].value.ptr);
+                break;
+            }
+        }
+        PyMem_DEL(quals);
+        PyMem_DEL(qualinfo);
+    }
 
-	return res;
+    return res;
 }
 
 PyDoc_STRVAR(al_GetParamInfo__doc__,
@@ -1686,81 +1686,81 @@
 static PyObject *
 al_GetParamInfo(PyObject *self, PyObject *args)
 {
-	int res, param;
-	ALparamInfo pinfo;
-	PyObject *v, *item;
+    int res, param;
+    ALparamInfo pinfo;
+    PyObject *v, *item;
 
-	if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
-		return NULL;
-	if (alGetParamInfo(res, param, &pinfo) < 0)
-		return NULL;
-	v = PyDict_New();
-	if (!v) return NULL;
+    if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
+        return NULL;
+    if (alGetParamInfo(res, param, &pinfo) < 0)
+        return NULL;
+    v = PyDict_New();
+    if (!v) return NULL;
 
-	item = PyInt_FromLong((long) pinfo.resource);
-	PyDict_SetItemString(v, "resource", item);
-	Py_DECREF(item);
+    item = PyInt_FromLong((long) pinfo.resource);
+    PyDict_SetItemString(v, "resource", item);
+    Py_DECREF(item);
 
-	item = PyInt_FromLong((long) pinfo.param);
-	PyDict_SetItemString(v, "param", item);
-	Py_DECREF(item);
+    item = PyInt_FromLong((long) pinfo.param);
+    PyDict_SetItemString(v, "param", item);
+    Py_DECREF(item);
 
-	item = PyInt_FromLong((long) pinfo.valueType);
-	PyDict_SetItemString(v, "valueType", item);
-	Py_DECREF(item);
+    item = PyInt_FromLong((long) pinfo.valueType);
+    PyDict_SetItemString(v, "valueType", item);
+    Py_DECREF(item);
 
-	if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
-		/* multiple values */
-		item = PyInt_FromLong((long) pinfo.maxElems);
-		PyDict_SetItemString(v, "maxElems", item);
-		Py_DECREF(item);
+    if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
+        /* multiple values */
+        item = PyInt_FromLong((long) pinfo.maxElems);
+        PyDict_SetItemString(v, "maxElems", item);
+        Py_DECREF(item);
 
-		if (pinfo.valueType == AL_MATRIX_VAL) {
-			/* 2 dimensional */
-			item = PyInt_FromLong((long) pinfo.maxElems2);
-			PyDict_SetItemString(v, "maxElems2", item);
-			Py_DECREF(item);
-		}
-	}
+        if (pinfo.valueType == AL_MATRIX_VAL) {
+            /* 2 dimensional */
+            item = PyInt_FromLong((long) pinfo.maxElems2);
+            PyDict_SetItemString(v, "maxElems2", item);
+            Py_DECREF(item);
+        }
+    }
 
-	item = PyInt_FromLong((long) pinfo.elementType);
-	PyDict_SetItemString(v, "elementType", item);
-	Py_DECREF(item);
+    item = PyInt_FromLong((long) pinfo.elementType);
+    PyDict_SetItemString(v, "elementType", item);
+    Py_DECREF(item);
 
-	item = PyString_FromString(pinfo.name);
-	PyDict_SetItemString(v, "name", item);
-	Py_DECREF(item);
+    item = PyString_FromString(pinfo.name);
+    PyDict_SetItemString(v, "name", item);
+    Py_DECREF(item);
 
-	item = param2python(res, param, pinfo.initial, &pinfo);
-	PyDict_SetItemString(v, "initial", item);
-	Py_DECREF(item);
+    item = param2python(res, param, pinfo.initial, &pinfo);
+    PyDict_SetItemString(v, "initial", item);
+    Py_DECREF(item);
 
-	if (pinfo.elementType != AL_ENUM_ELEM &&
-	    pinfo.elementType != AL_RESOURCE_ELEM &&
-	    pinfo.elementType != AL_CHAR_ELEM) {
-		/* range param */
-		item = param2python(res, param, pinfo.min, &pinfo);
-		PyDict_SetItemString(v, "min", item);
-		Py_DECREF(item);
+    if (pinfo.elementType != AL_ENUM_ELEM &&
+        pinfo.elementType != AL_RESOURCE_ELEM &&
+        pinfo.elementType != AL_CHAR_ELEM) {
+        /* range param */
+        item = param2python(res, param, pinfo.min, &pinfo);
+        PyDict_SetItemString(v, "min", item);
+        Py_DECREF(item);
 
-		item = param2python(res, param, pinfo.max, &pinfo);
-		PyDict_SetItemString(v, "max", item);
-		Py_DECREF(item);
+        item = param2python(res, param, pinfo.max, &pinfo);
+        PyDict_SetItemString(v, "max", item);
+        Py_DECREF(item);
 
-		item = param2python(res, param, pinfo.minDelta, &pinfo);
-		PyDict_SetItemString(v, "minDelta", item);
-		Py_DECREF(item);
+        item = param2python(res, param, pinfo.minDelta, &pinfo);
+        PyDict_SetItemString(v, "minDelta", item);
+        Py_DECREF(item);
 
-		item = param2python(res, param, pinfo.maxDelta, &pinfo);
-		PyDict_SetItemString(v, "maxDelta", item);
-		Py_DECREF(item);
+        item = param2python(res, param, pinfo.maxDelta, &pinfo);
+        PyDict_SetItemString(v, "maxDelta", item);
+        Py_DECREF(item);
 
-		item = PyInt_FromLong((long) pinfo.specialVals);
-		PyDict_SetItemString(v, "specialVals", item);
-		Py_DECREF(item);
-	}
+        item = PyInt_FromLong((long) pinfo.specialVals);
+        PyDict_SetItemString(v, "specialVals", item);
+        Py_DECREF(item);
+    }
 
-	return v;
+    return v;
 }
 
 PyDoc_STRVAR(al_GetResourceByName__doc__,
@@ -1769,14 +1769,14 @@
 static PyObject *
 al_GetResourceByName(PyObject *self, PyObject *args)
 {
-	int res, start_res, type;
-	char *name;
+    int res, start_res, type;
+    char *name;
 
-	if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
-		return NULL;
-	if ((res = alGetResourceByName(start_res, name, type)) == 0)
-		return NULL;
-	return PyInt_FromLong((long) res);
+    if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
+        return NULL;
+    if ((res = alGetResourceByName(start_res, name, type)) == 0)
+        return NULL;
+    return PyInt_FromLong((long) res);
 }
 
 PyDoc_STRVAR(al_IsSubtype__doc__,
@@ -1785,11 +1785,11 @@
 static PyObject *
 al_IsSubtype(PyObject *self, PyObject *args)
 {
-	int type, subtype;
+    int type, subtype;
 
-	if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
-		return NULL;
-	return PyInt_FromLong((long) alIsSubtype(type, subtype));
+    if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
+        return NULL;
+    return PyInt_FromLong((long) alIsSubtype(type, subtype));
 }
 
 PyDoc_STRVAR(al_SetErrorHandler__doc__, "");
@@ -1798,10 +1798,10 @@
 al_SetErrorHandler(PyObject *self, PyObject *args)
 {
 
-	if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
-		return NULL;
-	Py_INCREF(Py_None);
-	return Py_None;
+    if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
+        return NULL;
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 #endif /* AL_NO_ELEM */
@@ -1811,144 +1811,144 @@
 static PyObject *
 al_openport(PyObject *self, PyObject *args)
 {
-	char *name, *dir;
-	ALport port;
-	alcobject *config = NULL;
+    char *name, *dir;
+    ALport port;
+    alcobject *config = NULL;
 
-	if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
-		return NULL;
-	if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
-		return NULL;
-	return newalpobject(port);
+    if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
+        return NULL;
+    if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
+        return NULL;
+    return newalpobject(port);
 }
 
 static PyObject *
 al_newconfig(PyObject *self, PyObject *args)
 {
-	ALconfig config;
+    ALconfig config;
 
-	if (!PyArg_ParseTuple(args, ":NewConfig"))
-		return NULL;
-	if ((config = ALnewconfig ()) == NULL)
-		return NULL;
-	return newalcobject(config);
+    if (!PyArg_ParseTuple(args, ":NewConfig"))
+        return NULL;
+    if ((config = ALnewconfig ()) == NULL)
+        return NULL;
+    return newalcobject(config);
 }
 
 static PyObject *
 al_queryparams(PyObject *self, PyObject *args)
 {
-	long device;
-	long length;
-	long *PVbuffer;
-	long PVdummy[2];
-	PyObject *v = NULL;
-	int i;
+    long device;
+    long length;
+    long *PVbuffer;
+    long PVdummy[2];
+    PyObject *v = NULL;
+    int i;
 
-	if (!PyArg_ParseTuple(args, "l:queryparams", &device))
-		return NULL;
-	if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
-		return NULL;
-	if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
-		return PyErr_NoMemory();
-	if (ALqueryparams(device, PVbuffer, length) >= 0 &&
-	    (v = PyList_New((int)length)) != NULL) {
-		for (i = 0; i < length; i++)
-			PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
-	}
-	PyMem_DEL(PVbuffer);
-	return v;
+    if (!PyArg_ParseTuple(args, "l:queryparams", &device))
+        return NULL;
+    if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
+        return NULL;
+    if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
+        return PyErr_NoMemory();
+    if (ALqueryparams(device, PVbuffer, length) >= 0 &&
+        (v = PyList_New((int)length)) != NULL) {
+        for (i = 0; i < length; i++)
+            PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
+    }
+    PyMem_DEL(PVbuffer);
+    return v;
 }
 
 static PyObject *
 doParams(PyObject *args, int (*func)(long, long *, long), int modified)
 {
-	long device;
-	PyObject *list, *v;
-	long *PVbuffer;
-	long length;
-	int i;
-	
-	if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
-		return NULL;
-	length = PyList_Size(list);
-	PVbuffer = PyMem_NEW(long, length);
-	if (PVbuffer == NULL)
-		return PyErr_NoMemory();
-	for (i = 0; i < length; i++) {
-		v = PyList_GetItem(list, i);
-		if (!PyInt_Check(v)) {
-			PyMem_DEL(PVbuffer);
-			PyErr_BadArgument();
-			return NULL;
-		}
-		PVbuffer[i] = PyInt_AsLong(v);
-	}
+    long device;
+    PyObject *list, *v;
+    long *PVbuffer;
+    long length;
+    int i;
 
-	if ((*func)(device, PVbuffer, length) == -1) {
-		PyMem_DEL(PVbuffer);
-		return NULL;
-	}
+    if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
+        return NULL;
+    length = PyList_Size(list);
+    PVbuffer = PyMem_NEW(long, length);
+    if (PVbuffer == NULL)
+        return PyErr_NoMemory();
+    for (i = 0; i < length; i++) {
+        v = PyList_GetItem(list, i);
+        if (!PyInt_Check(v)) {
+            PyMem_DEL(PVbuffer);
+            PyErr_BadArgument();
+            return NULL;
+        }
+        PVbuffer[i] = PyInt_AsLong(v);
+    }
 
-	if (modified) {
-		for (i = 0; i < length; i++)
-			PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
-	}
+    if ((*func)(device, PVbuffer, length) == -1) {
+        PyMem_DEL(PVbuffer);
+        return NULL;
+    }
 
-	PyMem_DEL(PVbuffer);
+    if (modified) {
+        for (i = 0; i < length; i++)
+            PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
+    }
 
-	Py_INCREF(Py_None);
-	return Py_None;
+    PyMem_DEL(PVbuffer);
+
+    Py_INCREF(Py_None);
+    return Py_None;
 }
 
 static PyObject *
 al_getparams(PyObject *self, PyObject *args)
 {
-	return doParams(args, ALgetparams, 1);
+    return doParams(args, ALgetparams, 1);
 }
 
 static PyObject *
 al_setparams(PyObject *self, PyObject *args)
 {
-	return doParams(args, ALsetparams, 0);
+    return doParams(args, ALsetparams, 0);
 }
 
 static PyObject *
 al_getname(PyObject *self, PyObject *args)
 {
-	long device, descriptor;
-	char *name;
+    long device, descriptor;
+    char *name;
 
-	if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
-		return NULL;
-	if ((name = ALgetname(device, descriptor)) == NULL)
-		return NULL;
-	return PyString_FromString(name);
+    if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
+        return NULL;
+    if ((name = ALgetname(device, descriptor)) == NULL)
+        return NULL;
+    return PyString_FromString(name);
 }
 
 static PyObject *
 al_getdefault(PyObject *self, PyObject *args)
 {
-	long device, descriptor, value;
+    long device, descriptor, value;
 
-	if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
-		return NULL;
-	if ((value = ALgetdefault(device, descriptor)) == -1)
-		return NULL;
-	return PyLong_FromLong(value);
+    if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
+        return NULL;
+    if ((value = ALgetdefault(device, descriptor)) == -1)
+        return NULL;
+    return PyLong_FromLong(value);
 }
 
 static PyObject *
 al_getminmax(PyObject *self, PyObject *args)
 {
-	long device, descriptor, min, max;
+    long device, descriptor, min, max;
 
-	if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
-		return NULL;
-	min = -1;
-	max = -1;
-	if (ALgetminmax(device, descriptor, &min, &max) == -1)
-		return NULL;
-	return Py_BuildValue("ll", min, max);
+    if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
+        return NULL;
+    min = -1;
+    max = -1;
+    if (ALgetminmax(device, descriptor, &min, &max) == -1)
+        return NULL;
+    return Py_BuildValue("ll", min, max);
 }
 
 #endif /* OLD_INTERFACE */
@@ -1956,34 +1956,34 @@
 /* List of methods defined in the module */
 
 static struct PyMethodDef al_methods[] = {
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-	{"NewConfig",	(PyCFunction)al_NewConfig,	METH_VARARGS,	al_NewConfig__doc__},
-	{"OpenPort",	(PyCFunction)al_OpenPort,	METH_VARARGS,	al_OpenPort__doc__},
-	{"Connect",	(PyCFunction)al_Connect,	METH_VARARGS,	al_Connect__doc__},
-	{"Disconnect",	(PyCFunction)al_Disconnect,	METH_VARARGS,	al_Disconnect__doc__},
-	{"GetParams",	(PyCFunction)al_GetParams,	METH_VARARGS,	al_GetParams__doc__},
-	{"SetParams",	(PyCFunction)al_SetParams,	METH_VARARGS,	al_SetParams__doc__},
-	{"QueryValues",	(PyCFunction)al_QueryValues,	METH_VARARGS,	al_QueryValues__doc__},
-	{"GetParamInfo",	(PyCFunction)al_GetParamInfo,	METH_VARARGS,	al_GetParamInfo__doc__},
-	{"GetResourceByName",	(PyCFunction)al_GetResourceByName,	METH_VARARGS,	al_GetResourceByName__doc__},
-	{"IsSubtype",	(PyCFunction)al_IsSubtype,	METH_VARARGS,	al_IsSubtype__doc__},
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+    {"NewConfig",       (PyCFunction)al_NewConfig,      METH_VARARGS,   al_NewConfig__doc__},
+    {"OpenPort",        (PyCFunction)al_OpenPort,       METH_VARARGS,   al_OpenPort__doc__},
+    {"Connect",         (PyCFunction)al_Connect,        METH_VARARGS,   al_Connect__doc__},
+    {"Disconnect",      (PyCFunction)al_Disconnect,     METH_VARARGS,   al_Disconnect__doc__},
+    {"GetParams",       (PyCFunction)al_GetParams,      METH_VARARGS,   al_GetParams__doc__},
+    {"SetParams",       (PyCFunction)al_SetParams,      METH_VARARGS,   al_SetParams__doc__},
+    {"QueryValues",     (PyCFunction)al_QueryValues,    METH_VARARGS,   al_QueryValues__doc__},
+    {"GetParamInfo",            (PyCFunction)al_GetParamInfo,   METH_VARARGS,   al_GetParamInfo__doc__},
+    {"GetResourceByName",       (PyCFunction)al_GetResourceByName,      METH_VARARGS,   al_GetResourceByName__doc__},
+    {"IsSubtype",       (PyCFunction)al_IsSubtype,      METH_VARARGS,   al_IsSubtype__doc__},
 #if 0
-	/* this one not supported */
-	{"SetErrorHandler",	(PyCFunction)al_SetErrorHandler,	METH_VARARGS,	al_SetErrorHandler__doc__},
+    /* this one not supported */
+    {"SetErrorHandler",         (PyCFunction)al_SetErrorHandler,        METH_VARARGS,   al_SetErrorHandler__doc__},
 #endif
 #endif /* AL_NO_ELEM */
 #ifdef OLD_INTERFACE
-	{"openport",		(PyCFunction)al_openport,	METH_VARARGS},
-	{"newconfig",		(PyCFunction)al_newconfig,	METH_VARARGS},
-	{"queryparams",		(PyCFunction)al_queryparams,	METH_VARARGS},
-	{"getparams",		(PyCFunction)al_getparams,	METH_VARARGS},
-	{"setparams",		(PyCFunction)al_setparams,	METH_VARARGS},
-	{"getname",		(PyCFunction)al_getname,	METH_VARARGS},
-	{"getdefault",		(PyCFunction)al_getdefault,	METH_VARARGS},
-	{"getminmax",		(PyCFunction)al_getminmax,	METH_VARARGS},
+    {"openport",                (PyCFunction)al_openport,       METH_VARARGS},
+    {"newconfig",               (PyCFunction)al_newconfig,      METH_VARARGS},
+    {"queryparams",             (PyCFunction)al_queryparams,    METH_VARARGS},
+    {"getparams",               (PyCFunction)al_getparams,      METH_VARARGS},
+    {"setparams",               (PyCFunction)al_setparams,      METH_VARARGS},
+    {"getname",                 (PyCFunction)al_getname,        METH_VARARGS},
+    {"getdefault",              (PyCFunction)al_getdefault,     METH_VARARGS},
+    {"getminmax",               (PyCFunction)al_getminmax,      METH_VARARGS},
 #endif /* OLD_INTERFACE */
 
-	{NULL,	 (PyCFunction)NULL, 0, NULL}		/* sentinel */
+    {NULL,       (PyCFunction)NULL, 0, NULL}            /* sentinel */
 };
 
 
@@ -1994,1239 +1994,1239 @@
 void
 inital(void)
 {
-	PyObject *m, *d, *x;
+    PyObject *m, *d, *x;
 
-	if (PyErr_WarnPy3k("the al module has been removed in "
-	                   "Python 3.0", 2) < 0)
-	    return;	
+    if (PyErr_WarnPy3k("the al module has been removed in "
+                       "Python 3.0", 2) < 0)
+        return;
 
-	/* Create the module and add the functions */
-	m = Py_InitModule4("al", al_methods,
-		al_module_documentation,
-		(PyObject*)NULL,PYTHON_API_VERSION);
-	if (m == NULL)
-		return;
+    /* Create the module and add the functions */
+    m = Py_InitModule4("al", al_methods,
+        al_module_documentation,
+        (PyObject*)NULL,PYTHON_API_VERSION);
+    if (m == NULL)
+        return;
 
-	/* Add some symbolic constants to the module */
-	d = PyModule_GetDict(m);
-	ErrorObject = PyErr_NewException("al.error", NULL, NULL);
-	PyDict_SetItemString(d, "error", ErrorObject);
+    /* Add some symbolic constants to the module */
+    d = PyModule_GetDict(m);
+    ErrorObject = PyErr_NewException("al.error", NULL, NULL);
+    PyDict_SetItemString(d, "error", ErrorObject);
 
-	/* XXXX Add constants here */
+    /* XXXX Add constants here */
 #ifdef AL_4CHANNEL
-	x =  PyInt_FromLong((long) AL_4CHANNEL);
-	if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_4CHANNEL);
+    if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ADAT_IF_TYPE
-	x =  PyInt_FromLong((long) AL_ADAT_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ADAT_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ADAT_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_AES_IF_TYPE
-	x =  PyInt_FromLong((long) AL_AES_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_AES_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_AES_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_AES_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_AES_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ANALOG_IF_TYPE
-	x =  PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ASSOCIATE
-	x =  PyInt_FromLong((long) AL_ASSOCIATE);
-	if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ASSOCIATE);
+    if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_BUFFER_NULL
-	x =  PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_BUFFERLENGTH
-	x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_BUFFERLENGTH_NEG
-	x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_BUFFERLENGTH_ODD
-	x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_CHANNELS
-	x =  PyInt_FromLong((long) AL_BAD_CHANNELS);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_CHANNELS);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_CONFIG
-	x =  PyInt_FromLong((long) AL_BAD_CONFIG);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_CONFIG);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_COUNT_NEG
-	x =  PyInt_FromLong((long) AL_BAD_COUNT_NEG);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_COUNT_NEG);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_DEVICE
-	x =  PyInt_FromLong((long) AL_BAD_DEVICE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_DEVICE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_DEVICE_ACCESS
-	x =  PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_DIRECTION
-	x =  PyInt_FromLong((long) AL_BAD_DIRECTION);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_DIRECTION);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_FILLPOINT
-	x =  PyInt_FromLong((long) AL_BAD_FILLPOINT);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_FILLPOINT);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_FLOATMAX
-	x =  PyInt_FromLong((long) AL_BAD_FLOATMAX);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_FLOATMAX);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_ILLEGAL_STATE
-	x =  PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_NO_PORTS
-	x =  PyInt_FromLong((long) AL_BAD_NO_PORTS);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_NO_PORTS);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_NOT_FOUND
-	x =  PyInt_FromLong((long) AL_BAD_NOT_FOUND);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_NOT_FOUND);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_NOT_IMPLEMENTED
-	x =  PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_OUT_OF_MEM
-	x =  PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_PARAM
-	x =  PyInt_FromLong((long) AL_BAD_PARAM);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_PARAM);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_PERMISSIONS
-	x =  PyInt_FromLong((long) AL_BAD_PERMISSIONS);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_PERMISSIONS);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_PORT
-	x =  PyInt_FromLong((long) AL_BAD_PORT);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_PORT);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_PORTSTYLE
-	x =  PyInt_FromLong((long) AL_BAD_PORTSTYLE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_PORTSTYLE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_PVBUFFER
-	x =  PyInt_FromLong((long) AL_BAD_PVBUFFER);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_PVBUFFER);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_QSIZE
-	x =  PyInt_FromLong((long) AL_BAD_QSIZE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_QSIZE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_RATE
-	x =  PyInt_FromLong((long) AL_BAD_RATE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_RATE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_RESOURCE
-	x =  PyInt_FromLong((long) AL_BAD_RESOURCE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_RESOURCE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_SAMPFMT
-	x =  PyInt_FromLong((long) AL_BAD_SAMPFMT);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_SAMPFMT);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_TRANSFER_SIZE
-	x =  PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_BAD_WIDTH
-	x =  PyInt_FromLong((long) AL_BAD_WIDTH);
-	if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_BAD_WIDTH);
+    if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CHANNEL_MODE
-	x =  PyInt_FromLong((long) AL_CHANNEL_MODE);
-	if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CHANNEL_MODE);
+    if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CHANNELS
-	x =  PyInt_FromLong((long) AL_CHANNELS);
-	if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CHANNELS);
+    if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CHAR_ELEM
-	x =  PyInt_FromLong((long) AL_CHAR_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CHAR_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CLOCK_GEN
-	x =  PyInt_FromLong((long) AL_CLOCK_GEN);
-	if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CLOCK_GEN);
+    if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CLOCKGEN_TYPE
-	x =  PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CONNECT
-	x =  PyInt_FromLong((long) AL_CONNECT);
-	if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CONNECT);
+    if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CONNECTION_TYPE
-	x =  PyInt_FromLong((long) AL_CONNECTION_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CONNECTION_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CONNECTIONS
-	x =  PyInt_FromLong((long) AL_CONNECTIONS);
-	if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CONNECTIONS);
+    if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_CRYSTAL_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEFAULT_DEVICE
-	x =  PyInt_FromLong((long) AL_DEFAULT_DEVICE);
-	if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEFAULT_DEVICE);
+    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEFAULT_INPUT
-	x =  PyInt_FromLong((long) AL_DEFAULT_INPUT);
-	if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEFAULT_INPUT);
+    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEFAULT_OUTPUT
-	x =  PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
-	if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
+    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEST
-	x =  PyInt_FromLong((long) AL_DEST);
-	if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEST);
+    if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEVICE_TYPE
-	x =  PyInt_FromLong((long) AL_DEVICE_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEVICE_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DEVICES
-	x =  PyInt_FromLong((long) AL_DEVICES);
-	if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DEVICES);
+    if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DIGITAL_IF_TYPE
-	x =  PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DIGITAL_INPUT_RATE
-	x =  PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
-	if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
+    if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_DISCONNECT
-	x =  PyInt_FromLong((long) AL_DISCONNECT);
-	if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_DISCONNECT);
+    if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ENUM_ELEM
-	x =  PyInt_FromLong((long) AL_ENUM_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ENUM_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ENUM_VALUE
-	x =  PyInt_FromLong((long) AL_ENUM_VALUE);
-	if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ENUM_VALUE);
+    if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_INPUT_OVERFLOW
-	x =  PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_LENGTH
-	x =  PyInt_FromLong((long) AL_ERROR_LENGTH);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_LENGTH);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_LOCATION_LSP
-	x =  PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_LOCATION_MSP
-	x =  PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_NUMBER
-	x =  PyInt_FromLong((long) AL_ERROR_NUMBER);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_NUMBER);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_OUTPUT_UNDERFLOW
-	x =  PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_ERROR_TYPE
-	x =  PyInt_FromLong((long) AL_ERROR_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_ERROR_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_FIXED_ELEM
-	x =  PyInt_FromLong((long) AL_FIXED_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_FIXED_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_FIXED_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_GAIN
-	x =  PyInt_FromLong((long) AL_GAIN);
-	if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_GAIN);
+    if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_GAIN_REF
-	x =  PyInt_FromLong((long) AL_GAIN_REF);
-	if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_GAIN_REF);
+    if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_HRB_TYPE
-	x =  PyInt_FromLong((long) AL_HRB_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_HRB_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_COUNT
-	x =  PyInt_FromLong((long) AL_INPUT_COUNT);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_COUNT);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_DEVICE_TYPE
-	x =  PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_DIGITAL
-	x =  PyInt_FromLong((long) AL_INPUT_DIGITAL);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_DIGITAL);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_HRB_TYPE
-	x =  PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_LINE
-	x =  PyInt_FromLong((long) AL_INPUT_LINE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_LINE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_MIC
-	x =  PyInt_FromLong((long) AL_INPUT_MIC);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_MIC);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_PORT_TYPE
-	x =  PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_RATE
-	x =  PyInt_FromLong((long) AL_INPUT_RATE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_RATE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INPUT_SOURCE
-	x =  PyInt_FromLong((long) AL_INPUT_SOURCE);
-	if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INPUT_SOURCE);
+    if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INT32_ELEM
-	x =  PyInt_FromLong((long) AL_INT32_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INT32_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INT64_ELEM
-	x =  PyInt_FromLong((long) AL_INT64_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INT64_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INTERFACE
-	x =  PyInt_FromLong((long) AL_INTERFACE);
-	if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INTERFACE);
+    if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INTERFACE_TYPE
-	x =  PyInt_FromLong((long) AL_INTERFACE_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INTERFACE_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INVALID_PARAM
-	x =  PyInt_FromLong((long) AL_INVALID_PARAM);
-	if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INVALID_PARAM);
+    if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_INVALID_VALUE
-	x =  PyInt_FromLong((long) AL_INVALID_VALUE);
-	if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_INVALID_VALUE);
+    if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_JITTER
-	x =  PyInt_FromLong((long) AL_JITTER);
-	if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_JITTER);
+    if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LABEL
-	x =  PyInt_FromLong((long) AL_LABEL);
-	if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LABEL);
+    if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LEFT_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LEFT_MONITOR_ATTEN
-	x =  PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LEFT_SPEAKER_GAIN
-	x =  PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
-	if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
+    if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LEFT1_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LEFT2_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LINE_IF_TYPE
-	x =  PyInt_FromLong((long) AL_LINE_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LINE_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_LOCKED
-	x =  PyInt_FromLong((long) AL_LOCKED);
-	if (x == NULL || PyDict_SetItemString(d, "LOCKED", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_LOCKED);
+    if (x == NULL || PyDict_SetItemString(d, "LOCKED", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MASTER_CLOCK
-	x =  PyInt_FromLong((long) AL_MASTER_CLOCK);
-	if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MASTER_CLOCK);
+    if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MATRIX_VAL
-	x =  PyInt_FromLong((long) AL_MATRIX_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MATRIX_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_ERROR
-	x =  PyInt_FromLong((long) AL_MAX_ERROR);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_ERROR);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_EVENT_PARAM
-	x =  PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_PBUFSIZE
-	x =  PyInt_FromLong((long) AL_MAX_PBUFSIZE);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_PBUFSIZE);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_PORTS
-	x =  PyInt_FromLong((long) AL_MAX_PORTS);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_PORTS);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_RESOURCE_ID
-	x =  PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_SETSIZE
-	x =  PyInt_FromLong((long) AL_MAX_SETSIZE);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_SETSIZE);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MAX_STRLEN
-	x =  PyInt_FromLong((long) AL_MAX_STRLEN);
-	if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MAX_STRLEN);
+    if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MIC_IF_TYPE
-	x =  PyInt_FromLong((long) AL_MIC_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MIC_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MONITOR_CTL
-	x =  PyInt_FromLong((long) AL_MONITOR_CTL);
-	if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MONITOR_CTL);
+    if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MONITOR_OFF
-	x =  PyInt_FromLong((long) AL_MONITOR_OFF);
-	if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MONITOR_OFF);
+    if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MONITOR_ON
-	x =  PyInt_FromLong((long) AL_MONITOR_ON);
-	if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MONITOR_ON);
+    if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MONO
-	x =  PyInt_FromLong((long) AL_MONO);
-	if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MONO);
+    if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_MUTE
-	x =  PyInt_FromLong((long) AL_MUTE);
-	if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_MUTE);
+    if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NAME
-	x =  PyInt_FromLong((long) AL_NAME);
-	if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NAME);
+    if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NEG_INFINITY
-	x =  PyInt_FromLong((long) AL_NEG_INFINITY);
-	if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NEG_INFINITY);
+    if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NEG_INFINITY_BIT
-	x =  PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
-	if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
+    if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_CHANGE
-	x =  PyInt_FromLong((long) AL_NO_CHANGE);
-	if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_CHANGE);
+    if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_CHANGE_BIT
-	x =  PyInt_FromLong((long) AL_NO_CHANGE_BIT);
-	if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_CHANGE_BIT);
+    if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_ELEM
-	x =  PyInt_FromLong((long) AL_NO_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_ERRORS
-	x =  PyInt_FromLong((long) AL_NO_ERRORS);
-	if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_ERRORS);
+    if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_OP
-	x =  PyInt_FromLong((long) AL_NO_OP);
-	if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_OP);
+    if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NO_VAL
-	x =  PyInt_FromLong((long) AL_NO_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NO_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NULL_INTERFACE
-	x =  PyInt_FromLong((long) AL_NULL_INTERFACE);
-	if (x == NULL || PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NULL_INTERFACE);
+    if (x == NULL || PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_NULL_RESOURCE
-	x =  PyInt_FromLong((long) AL_NULL_RESOURCE);
-	if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_NULL_RESOURCE);
+    if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OPTICAL_IF_TYPE
-	x =  PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OUTPUT_COUNT
-	x =  PyInt_FromLong((long) AL_OUTPUT_COUNT);
-	if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OUTPUT_COUNT);
+    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OUTPUT_DEVICE_TYPE
-	x =  PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OUTPUT_HRB_TYPE
-	x =  PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OUTPUT_PORT_TYPE
-	x =  PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_OUTPUT_RATE
-	x =  PyInt_FromLong((long) AL_OUTPUT_RATE);
-	if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_OUTPUT_RATE);
+    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PARAM_BIT
-	x =  PyInt_FromLong((long) AL_PARAM_BIT);
-	if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PARAM_BIT);
+    if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PARAMS
-	x =  PyInt_FromLong((long) AL_PARAMS);
-	if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PARAMS);
+    if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PORT_COUNT
-	x =  PyInt_FromLong((long) AL_PORT_COUNT);
-	if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PORT_COUNT);
+    if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PORT_TYPE
-	x =  PyInt_FromLong((long) AL_PORT_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PORT_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PORTS
-	x =  PyInt_FromLong((long) AL_PORTS);
-	if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PORTS);
+    if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PORTSTYLE_DIRECT
-	x =  PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
-	if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
+    if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PORTSTYLE_SERIAL
-	x =  PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
-	if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
+    if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PRINT_ERRORS
-	x =  PyInt_FromLong((long) AL_PRINT_ERRORS);
-	if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PRINT_ERRORS);
+    if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_PTR_ELEM
-	x =  PyInt_FromLong((long) AL_PTR_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_PTR_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RANGE_VALUE
-	x =  PyInt_FromLong((long) AL_RANGE_VALUE);
-	if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RANGE_VALUE);
+    if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE
-	x =  PyInt_FromLong((long) AL_RATE);
-	if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE);
+    if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_11025
-	x =  PyInt_FromLong((long) AL_RATE_11025);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_11025);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_16000
-	x =  PyInt_FromLong((long) AL_RATE_16000);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_16000);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_22050
-	x =  PyInt_FromLong((long) AL_RATE_22050);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_22050);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_32000
-	x =  PyInt_FromLong((long) AL_RATE_32000);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_32000);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_44100
-	x =  PyInt_FromLong((long) AL_RATE_44100);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_44100);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_48000
-	x =  PyInt_FromLong((long) AL_RATE_48000);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_48000);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_8000
-	x =  PyInt_FromLong((long) AL_RATE_8000);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_8000);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_1
-	x =  PyInt_FromLong((long) AL_RATE_AES_1);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_1);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_1s
-	x =  PyInt_FromLong((long) AL_RATE_AES_1s);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_1s);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_2
-	x =  PyInt_FromLong((long) AL_RATE_AES_2);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_2);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_3
-	x =  PyInt_FromLong((long) AL_RATE_AES_3);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_3);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_4
-	x =  PyInt_FromLong((long) AL_RATE_AES_4);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_4);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_AES_6
-	x =  PyInt_FromLong((long) AL_RATE_AES_6);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_AES_6);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_FRACTION_D
-	x =  PyInt_FromLong((long) AL_RATE_FRACTION_D);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_FRACTION_D);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_FRACTION_N
-	x =  PyInt_FromLong((long) AL_RATE_FRACTION_N);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_FRACTION_N);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_INPUTRATE
-	x =  PyInt_FromLong((long) AL_RATE_INPUTRATE);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_INPUTRATE);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_NO_DIGITAL_INPUT
-	x =  PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_UNACQUIRED
-	x =  PyInt_FromLong((long) AL_RATE_UNACQUIRED);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_UNACQUIRED);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RATE_UNDEFINED
-	x =  PyInt_FromLong((long) AL_RATE_UNDEFINED);
-	if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RATE_UNDEFINED);
+    if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_REF_0DBV
-	x =  PyInt_FromLong((long) AL_REF_0DBV);
-	if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_REF_0DBV);
+    if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_REF_NONE
-	x =  PyInt_FromLong((long) AL_REF_NONE);
-	if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_REF_NONE);
+    if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESERVED1_TYPE
-	x =  PyInt_FromLong((long) AL_RESERVED1_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESERVED1_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESERVED2_TYPE
-	x =  PyInt_FromLong((long) AL_RESERVED2_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESERVED2_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESERVED3_TYPE
-	x =  PyInt_FromLong((long) AL_RESERVED3_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESERVED3_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESERVED4_TYPE
-	x =  PyInt_FromLong((long) AL_RESERVED4_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESERVED4_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESOURCE
-	x =  PyInt_FromLong((long) AL_RESOURCE);
-	if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESOURCE);
+    if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESOURCE_ELEM
-	x =  PyInt_FromLong((long) AL_RESOURCE_ELEM);
-	if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESOURCE_ELEM);
+    if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RESOURCE_TYPE
-	x =  PyInt_FromLong((long) AL_RESOURCE_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RESOURCE_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RIGHT_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RIGHT_MONITOR_ATTEN
-	x =  PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RIGHT_SPEAKER_GAIN
-	x =  PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
-	if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
+    if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RIGHT1_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_RIGHT2_INPUT_ATTEN
-	x =  PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
-	if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
+    if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPFMT_DOUBLE
-	x =  PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPFMT_FLOAT
-	x =  PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPFMT_TWOSCOMP
-	x =  PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPLE_16
-	x =  PyInt_FromLong((long) AL_SAMPLE_16);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPLE_16);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPLE_24
-	x =  PyInt_FromLong((long) AL_SAMPLE_24);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPLE_24);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SAMPLE_8
-	x =  PyInt_FromLong((long) AL_SAMPLE_8);
-	if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SAMPLE_8);
+    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SCALAR_VAL
-	x =  PyInt_FromLong((long) AL_SCALAR_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SCALAR_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SET_VAL
-	x =  PyInt_FromLong((long) AL_SET_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SET_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SHORT_NAME
-	x =  PyInt_FromLong((long) AL_SHORT_NAME);
-	if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SHORT_NAME);
+    if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SMPTE272M_IF_TYPE
-	x =  PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SOURCE
-	x =  PyInt_FromLong((long) AL_SOURCE);
-	if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SOURCE);
+    if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SPEAKER_IF_TYPE
-	x =  PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SPEAKER_MUTE_CTL
-	x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
-	if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
+    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SPEAKER_MUTE_OFF
-	x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
-	if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
+    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SPEAKER_MUTE_ON
-	x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
-	if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
+    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
-	x =  PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_STEREO
-	x =  PyInt_FromLong((long) AL_STEREO);
-	if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_STEREO);
+    if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_STRING_VAL
-	x =  PyInt_FromLong((long) AL_STRING_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_STRING_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SUBSYSTEM
-	x =  PyInt_FromLong((long) AL_SUBSYSTEM);
-	if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SUBSYSTEM);
+    if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SUBSYSTEM_TYPE
-	x =  PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SYNC_INPUT_TO_AES
-	x =  PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
-	if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
+    if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SYNC_OUTPUT_TO_AES
-	x =  PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
-	if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
+    if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SYSTEM
-	x =  PyInt_FromLong((long) AL_SYSTEM);
-	if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SYSTEM);
+    if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_SYSTEM_TYPE
-	x =  PyInt_FromLong((long) AL_SYSTEM_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_SYSTEM_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_TEST_IF_TYPE
-	x =  PyInt_FromLong((long) AL_TEST_IF_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_TEST_IF_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_TYPE
-	x =  PyInt_FromLong((long) AL_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_TYPE_BIT
-	x =  PyInt_FromLong((long) AL_TYPE_BIT);
-	if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_TYPE_BIT);
+    if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_UNUSED_COUNT
-	x =  PyInt_FromLong((long) AL_UNUSED_COUNT);
-	if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_UNUSED_COUNT);
+    if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_UNUSED_PORTS
-	x =  PyInt_FromLong((long) AL_UNUSED_PORTS);
-	if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_UNUSED_PORTS);
+    if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_VARIABLE_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_VECTOR_VAL
-	x =  PyInt_FromLong((long) AL_VECTOR_VAL);
-	if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_VECTOR_VAL);
+    if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_VIDEO_MCLK_TYPE
-	x =  PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
-	if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
+    if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 #ifdef AL_WORDSIZE
-	x =  PyInt_FromLong((long) AL_WORDSIZE);
-	if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
-		goto error;
-	Py_DECREF(x);
+    x =  PyInt_FromLong((long) AL_WORDSIZE);
+    if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
+        goto error;
+    Py_DECREF(x);
 #endif
 
-#ifdef AL_NO_ELEM		/* IRIX 6 */
-	(void) alSetErrorHandler(ErrorHandler);
+#ifdef AL_NO_ELEM               /* IRIX 6 */
+    (void) alSetErrorHandler(ErrorHandler);
 #endif /* AL_NO_ELEM */
 #ifdef OLD_INTERFACE
-	(void) ALseterrorhandler(ErrorHandler);
+    (void) ALseterrorhandler(ErrorHandler);
 #endif /* OLD_INTERFACE */
-	
+
   error:
-	return;
+    return;
 }