Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Modules/almodule.c

    r2 r391  
    11
    2 #define OLD_INTERFACE           /* define for pre-Irix 6 interface */
     2#define OLD_INTERFACE           /* define for pre-Irix 6 interface */
    33
    44#include "Python.h"
    … …  
    2020
    2121typedef struct {
    22         PyObject_HEAD
    23         /* XXXX Add your own stuff here */
    24         ALport port;
     22    PyObject_HEAD
     23    /* XXXX Add your own stuff here */
     24    ALport port;
    2525} alpobject;
    2626
    … …  
    3434
    3535typedef struct {
    36         PyObject_HEAD
    37         /* XXXX Add your own stuff here */
    38         ALconfig config;
     36    PyObject_HEAD
     37    /* XXXX Add your own stuff here */
     38    ALconfig config;
    3939} alcobject;
    4040
    … …  
    4545ErrorHandler(long code, const char *fmt, ...)
    4646{
    47         va_list args;
    48         char buf[128];
    49 
    50         va_start(args, fmt);
    51         vsprintf(buf, fmt, args);
    52         va_end(args);
    53         PyErr_SetString(ErrorObject, buf);
    54 }
    55 
    56 #ifdef AL_NO_ELEM               /* IRIX 6 */
     47    va_list args;
     48    char buf[128];
     49
     50    va_start(args, fmt);
     51    vsprintf(buf, fmt, args);
     52    va_end(args);
     53    PyErr_SetString(ErrorObject, buf);
     54}
     55
     56#ifdef AL_NO_ELEM               /* IRIX 6 */
    5757
    5858static PyObject *
    5959param2python(int resource, int param, ALvalue value, ALparamInfo *pinfo)
    6060{
    61         ALparamInfo info;
    62 
    63         if (pinfo == NULL) {
    64                 pinfo = &info;
    65                 if (alGetParamInfo(resource, param, &info) < 0)
    66                         return NULL;
    67         }
    68         switch (pinfo->elementType) {
    69         case AL_PTR_ELEM:
    70                 /* XXXX don't know how to handle this */
    71         case AL_NO_ELEM:
    72                 Py_INCREF(Py_None);
    73                 return Py_None;
    74         case AL_INT32_ELEM:
    75         case AL_RESOURCE_ELEM:
    76         case AL_ENUM_ELEM:
    77                 return PyInt_FromLong((long) value.i);
    78         case AL_INT64_ELEM:
    79                 return PyLong_FromLongLong(value.ll);
    80         case AL_FIXED_ELEM:
    81                 return PyFloat_FromDouble(alFixedToDouble(value.ll));
    82         case AL_CHAR_ELEM:
    83                 if (value.ptr == NULL) {
    84                         Py_INCREF(Py_None);
    85                         return Py_None;
    86                 }
    87                 return PyString_FromString((char *) value.ptr);
    88         default:
    89                 PyErr_SetString(ErrorObject, "unknown element type");
    90                 return NULL;
    91         }
     61    ALparamInfo info;
     62
     63    if (pinfo == NULL) {
     64        pinfo = &info;
     65        if (alGetParamInfo(resource, param, &info) < 0)
     66            return NULL;
     67    }
     68    switch (pinfo->elementType) {
     69    case AL_PTR_ELEM:
     70        /* XXXX don't know how to handle this */
     71    case AL_NO_ELEM:
     72        Py_INCREF(Py_None);
     73        return Py_None;
     74    case AL_INT32_ELEM:
     75    case AL_RESOURCE_ELEM:
     76    case AL_ENUM_ELEM:
     77        return PyInt_FromLong((long) value.i);
     78    case AL_INT64_ELEM:
     79        return PyLong_FromLongLong(value.ll);
     80    case AL_FIXED_ELEM:
     81        return PyFloat_FromDouble(alFixedToDouble(value.ll));
     82    case AL_CHAR_ELEM:
     83        if (value.ptr == NULL) {
     84            Py_INCREF(Py_None);
     85            return Py_None;
     86        }
     87        return PyString_FromString((char *) value.ptr);
     88    default:
     89        PyErr_SetString(ErrorObject, "unknown element type");
     90        return NULL;
     91    }
    9292}
    9393
    … …  
    9595python2elem(PyObject *item, void *ptr, int elementType)
    9696{
    97         switch (elementType) {
    98         case AL_INT32_ELEM:
    99         case AL_RESOURCE_ELEM:
    100         case AL_ENUM_ELEM:
    101                 if (!PyInt_Check(item)) {
    102                         PyErr_BadArgument();
    103                         return -1;
    104                 }
    105                 *((int *) ptr) = PyInt_AsLong(item);
    106                 break;
    107         case AL_INT64_ELEM:
    108                 if (PyInt_Check(item))
    109                         *((long long *) ptr) = PyInt_AsLong(item);
    110                 else if (PyLong_Check(item))
    111                         *((long long *) ptr) = PyLong_AsLongLong(item);
    112                 else {
    113                         PyErr_BadArgument();
    114                         return -1;
    115                 }
    116                 break;
    117         case AL_FIXED_ELEM:
    118                 if (PyInt_Check(item))
    119                         *((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
    120                 else if (PyFloat_Check(item))
    121                         *((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
    122                 else {
    123                         PyErr_BadArgument();
    124                         return -1;
    125                 }
    126                 break;
    127         default:
    128                 PyErr_SetString(ErrorObject, "unknown element type");
    129                 return -1;
    130         }
    131         return 0;
     97    switch (elementType) {
     98    case AL_INT32_ELEM:
     99    case AL_RESOURCE_ELEM:
     100    case AL_ENUM_ELEM:
     101        if (!PyInt_Check(item)) {
     102            PyErr_BadArgument();
     103            return -1;
     104        }
     105        *((int *) ptr) = PyInt_AsLong(item);
     106        break;
     107    case AL_INT64_ELEM:
     108        if (PyInt_Check(item))
     109            *((long long *) ptr) = PyInt_AsLong(item);
     110        else if (PyLong_Check(item))
     111            *((long long *) ptr) = PyLong_AsLongLong(item);
     112        else {
     113            PyErr_BadArgument();
     114            return -1;
     115        }
     116        break;
     117    case AL_FIXED_ELEM:
     118        if (PyInt_Check(item))
     119            *((long long *) ptr) = alDoubleToFixed((double) PyInt_AsLong(item));
     120        else if (PyFloat_Check(item))
     121            *((long long *) ptr) = alDoubleToFixed(PyFloat_AsDouble(item));
     122        else {
     123            PyErr_BadArgument();
     124            return -1;
     125        }
     126        break;
     127    default:
     128        PyErr_SetString(ErrorObject, "unknown element type");
     129        return -1;
     130    }
     131    return 0;
    132132}
    133133
    … …  
    135135python2param(int resource, ALpv *param, PyObject *value, ALparamInfo *pinfo)
    136136{
    137         ALparamInfo info;
    138         int i, stepsize;
    139         PyObject *item;
    140 
    141         if (pinfo == NULL) {
    142                 pinfo = &info;
    143                 if (alGetParamInfo(resource, param->param, &info) < 0)
    144                         return -1;
    145         }
    146         switch (pinfo->valueType) {
    147         case AL_STRING_VAL:
    148                 if (pinfo->elementType != AL_CHAR_ELEM) {
    149                         PyErr_SetString(ErrorObject, "unknown element type");
    150                         return -1;
    151                 }
    152                 if (!PyString_Check(value)) {
    153                         PyErr_BadArgument();
    154                         return -1;
    155                 }
    156                 param->value.ptr = PyString_AS_STRING(value);
    157                 param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
    158                 break;
    159         case AL_SET_VAL:
    160         case AL_VECTOR_VAL:
    161                 if (!PyList_Check(value) && !PyTuple_Check(value)) {
    162                         PyErr_BadArgument();
    163                         return -1;
    164                 }
    165                 switch (pinfo->elementType) {
    166                 case AL_INT32_ELEM:
    167                 case AL_RESOURCE_ELEM:
    168                 case AL_ENUM_ELEM:
    169                         param->sizeIn = PySequence_Size(value);
    170                         param->value.ptr = PyMem_NEW(int, param->sizeIn);
    171                         stepsize = sizeof(int);
    172                         break;
    173                 case AL_INT64_ELEM:
    174                 case AL_FIXED_ELEM:
    175                         param->sizeIn = PySequence_Size(value);
    176                         param->value.ptr = PyMem_NEW(long long, param->sizeIn);
    177                         stepsize = sizeof(long long);
    178                         break;
    179                 }
    180                 for (i = 0; i < param->sizeIn; i++) {
    181                         item = PySequence_GetItem(value, i);
    182                         if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
    183                                 PyMem_DEL(param->value.ptr);
    184                                 return -1;
    185                         }
    186                 }
    187                 break;
    188         case AL_SCALAR_VAL:
    189                 switch (pinfo->elementType) {
    190                 case AL_INT32_ELEM:
    191                 case AL_RESOURCE_ELEM:
    192                 case AL_ENUM_ELEM:
    193                         return python2elem(value, (void *) &param->value.i,
    194                                            pinfo->elementType);
    195                 case AL_INT64_ELEM:
    196                 case AL_FIXED_ELEM:
    197                         return python2elem(value, (void *) &param->value.ll,
    198                                            pinfo->elementType);
    199                 default:
    200                         PyErr_SetString(ErrorObject, "unknown element type");
    201                         return -1;
    202                 }
    203         }
    204         return 0;
     137    ALparamInfo info;
     138    int i, stepsize;
     139    PyObject *item;
     140
     141    if (pinfo == NULL) {
     142        pinfo = &info;
     143        if (alGetParamInfo(resource, param->param, &info) < 0)
     144            return -1;
     145    }
     146    switch (pinfo->valueType) {
     147    case AL_STRING_VAL:
     148        if (pinfo->elementType != AL_CHAR_ELEM) {
     149            PyErr_SetString(ErrorObject, "unknown element type");
     150            return -1;
     151        }
     152        if (!PyString_Check(value)) {
     153            PyErr_BadArgument();
     154            return -1;
     155        }
     156        param->value.ptr = PyString_AS_STRING(value);
     157        param->sizeIn = PyString_GET_SIZE(value)+1; /*account for NUL*/
     158        break;
     159    case AL_SET_VAL:
     160    case AL_VECTOR_VAL:
     161        if (!PyList_Check(value) && !PyTuple_Check(value)) {
     162            PyErr_BadArgument();
     163            return -1;
     164        }
     165        switch (pinfo->elementType) {
     166        case AL_INT32_ELEM:
     167        case AL_RESOURCE_ELEM:
     168        case AL_ENUM_ELEM:
     169            param->sizeIn = PySequence_Size(value);
     170            param->value.ptr = PyMem_NEW(int, param->sizeIn);
     171            stepsize = sizeof(int);
     172            break;
     173        case AL_INT64_ELEM:
     174        case AL_FIXED_ELEM:
     175            param->sizeIn = PySequence_Size(value);
     176            param->value.ptr = PyMem_NEW(long long, param->sizeIn);
     177            stepsize = sizeof(long long);
     178            break;
     179        }
     180        for (i = 0; i < param->sizeIn; i++) {
     181            item = PySequence_GetItem(value, i);
     182            if (python2elem(item, (void *) ((char *) param->value.ptr + i*stepsize), pinfo->elementType) < 0) {
     183                PyMem_DEL(param->value.ptr);
     184                return -1;
     185            }
     186        }
     187        break;
     188    case AL_SCALAR_VAL:
     189        switch (pinfo->elementType) {
     190        case AL_INT32_ELEM:
     191        case AL_RESOURCE_ELEM:
     192        case AL_ENUM_ELEM:
     193            return python2elem(value, (void *) &param->value.i,
     194                               pinfo->elementType);
     195        case AL_INT64_ELEM:
     196        case AL_FIXED_ELEM:
     197            return python2elem(value, (void *) &param->value.ll,
     198                               pinfo->elementType);
     199        default:
     200            PyErr_SetString(ErrorObject, "unknown element type");
     201            return -1;
     202        }
     203    }
     204    return 0;
    205205}
    206206
    … …  
    208208python2params(int resource1, int resource2, PyObject *list, ALpv **pvsp, ALparamInfo **pinfop)
    209209{
    210         PyObject *item;
    211         ALpv *pvs;
    212         ALparamInfo *pinfo;
    213         int npvs, i;
    214 
    215         npvs = PyList_Size(list);
    216         pvs = PyMem_NEW(ALpv, npvs);
    217         pinfo = PyMem_NEW(ALparamInfo, npvs);
    218         for (i = 0; i < npvs; i++) {
    219                 item = PyList_GetItem(list, i);
    220                 if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
    221                         goto error;
    222                 if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
    223                     alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
    224                         goto error;
    225                 if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
    226                         goto error;
    227         }
    228 
    229         *pvsp = pvs;
    230         *pinfop = pinfo;
    231         return npvs;
     210    PyObject *item;
     211    ALpv *pvs;
     212    ALparamInfo *pinfo;
     213    int npvs, i;
     214
     215    npvs = PyList_Size(list);
     216    pvs = PyMem_NEW(ALpv, npvs);
     217    pinfo = PyMem_NEW(ALparamInfo, npvs);
     218    for (i = 0; i < npvs; i++) {
     219        item = PyList_GetItem(list, i);
     220        if (!PyArg_ParseTuple(item, "iO", &pvs[i].param, &item))
     221            goto error;
     222        if (alGetParamInfo(resource1, pvs[i].param, &pinfo[i]) < 0 &&
     223            alGetParamInfo(resource2, pvs[i].param, &pinfo[i]) < 0)
     224            goto error;
     225        if (python2param(resource1, &pvs[i], item, &pinfo[i]) < 0)
     226            goto error;
     227    }
     228
     229    *pvsp = pvs;
     230    *pinfop = pinfo;
     231    return npvs;
    232232
    233233  error:
    234         /* XXXX we should clean up everything */
    235         if (pvs)
    236                 PyMem_DEL(pvs);
    237         if (pinfo)
    238                 PyMem_DEL(pinfo);
    239         return -1;
     234    /* XXXX we should clean up everything */
     235    if (pvs)
     236        PyMem_DEL(pvs);
     237    if (pinfo)
     238        PyMem_DEL(pinfo);
     239    return -1;
    240240}
    241241
    … …  
    246246SetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig, int))
    247247{
    248         int par;
    249 
    250         if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
    251                 return NULL;
    252 
    253         if ((*func)(self->config, par) == -1)
    254                 return NULL;
    255 
    256         Py_INCREF(Py_None);
    257         return Py_None;
     248    int par;
     249
     250    if (!PyArg_ParseTuple(args, "i:SetConfig", &par))
     251        return NULL;
     252
     253    if ((*func)(self->config, par) == -1)
     254        return NULL;
     255
     256    Py_INCREF(Py_None);
     257    return Py_None;
    258258}
    259259
    260260static PyObject *
    261261GetConfig(alcobject *self, PyObject *args, int (*func)(ALconfig))
    262 {       
    263         int par;
    264 
    265         if (!PyArg_ParseTuple(args, ":GetConfig"))
    266                 return NULL;
    267        
    268         if ((par = (*func)(self->config)) == -1)
    269                 return NULL;
    270 
    271         return PyInt_FromLong((long) par);
     262{
     263    int par;
     264
     265    if (!PyArg_ParseTuple(args, ":GetConfig"))
     266        return NULL;
     267
     268    if ((par = (*func)(self->config)) == -1)
     269        return NULL;
     270
     271    return PyInt_FromLong((long) par);
    272272}
    273273
    … …  
    278278alc_SetWidth(alcobject *self, PyObject *args)
    279279{
    280         return SetConfig(self, args, alSetWidth);
     280    return SetConfig(self, args, alSetWidth);
    281281}
    282282
    … …  
    288288alc_GetWidth(alcobject *self, PyObject *args)
    289289{
    290         return GetConfig(self, args, alGetWidth);
     290    return GetConfig(self, args, alGetWidth);
    291291}
    292292
    … …  
    299299alc_SetSampFmt(alcobject *self, PyObject *args)
    300300{
    301         return SetConfig(self, args, alSetSampFmt);
     301    return SetConfig(self, args, alSetSampFmt);
    302302}
    303303
    … …  
    310310alc_GetSampFmt(alcobject *self, PyObject *args)
    311311{
    312         return GetConfig(self, args, alGetSampFmt);
     312    return GetConfig(self, args, alGetSampFmt);
    313313}
    314314
    … …  
    320320alc_SetChannels(alcobject *self, PyObject *args)
    321321{
    322         return SetConfig(self, args, alSetChannels);
     322    return SetConfig(self, args, alSetChannels);
    323323}
    324324
    … …  
    330330alc_GetChannels(alcobject *self, PyObject *args)
    331331{
    332         return GetConfig(self, args, alGetChannels);
     332    return GetConfig(self, args, alGetChannels);
    333333}
    334334
    … …  
    340340alc_SetFloatMax(alcobject *self, PyObject *args)
    341341{
    342         double maximum_value;
    343 
    344         if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
    345                 return NULL;
    346         if (alSetFloatMax(self->config, maximum_value) < 0)
    347                 return NULL;
    348         Py_INCREF(Py_None);
    349         return Py_None;
     342    double maximum_value;
     343
     344    if (!PyArg_ParseTuple(args, "d:SetFloatMax", &maximum_value))
     345        return NULL;
     346    if (alSetFloatMax(self->config, maximum_value) < 0)
     347        return NULL;
     348    Py_INCREF(Py_None);
     349    return Py_None;
    350350}
    351351
    … …  
    357357alc_GetFloatMax(alcobject *self, PyObject *args)
    358358{
    359         double maximum_value;
    360 
    361         if (!PyArg_ParseTuple(args, ":GetFloatMax"))
    362                 return NULL;
    363         if ((maximum_value = alGetFloatMax(self->config)) == 0)
    364                 return NULL;
    365         return PyFloat_FromDouble(maximum_value);
     359    double maximum_value;
     360
     361    if (!PyArg_ParseTuple(args, ":GetFloatMax"))
     362        return NULL;
     363    if ((maximum_value = alGetFloatMax(self->config)) == 0)
     364        return NULL;
     365    return PyFloat_FromDouble(maximum_value);
    366366}
    367367
    … …  
    373373alc_SetDevice(alcobject *self, PyObject *args)
    374374{
    375         return SetConfig(self, args, alSetDevice);
     375    return SetConfig(self, args, alSetDevice);
    376376}
    377377
    … …  
    383383alc_GetDevice(alcobject *self, PyObject *args)
    384384{
    385         return GetConfig(self, args, alGetDevice);
     385    return GetConfig(self, args, alGetDevice);
    386386}
    387387
    … …  
    393393alc_SetQueueSize(alcobject *self, PyObject *args)
    394394{
    395         return SetConfig(self, args, alSetQueueSize);
     395    return SetConfig(self, args, alSetQueueSize);
    396396}
    397397
    … …  
    403403alc_GetQueueSize(alcobject *self, PyObject *args)
    404404{
    405         return GetConfig(self, args, alGetQueueSize);
     405    return GetConfig(self, args, alGetQueueSize);
    406406}
    407407
    … …  
    411411setconfig(alcobject *self, PyObject *args, int (*func)(ALconfig, long))
    412412{
    413         long par;
    414 
    415         if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
    416                 return NULL;
    417 
    418         if ((*func)(self->config, par) == -1)
    419                 return NULL;
    420 
    421         Py_INCREF(Py_None);
    422         return Py_None;
     413    long par;
     414
     415    if (!PyArg_ParseTuple(args, "l:SetConfig", &par))
     416        return NULL;
     417
     418    if ((*func)(self->config, par) == -1)
     419        return NULL;
     420
     421    Py_INCREF(Py_None);
     422    return Py_None;
    423423}
    424424
    425425static PyObject *
    426426getconfig(alcobject *self, PyObject *args, long (*func)(ALconfig))
    427 {       
    428         long par;
    429 
    430         if (!PyArg_ParseTuple(args, ":GetConfig"))
    431                 return NULL;
    432        
    433         if ((par = (*func)(self->config)) == -1)
    434                 return NULL;
    435 
    436         return PyInt_FromLong((long) par);
     427{
     428    long par;
     429
     430    if (!PyArg_ParseTuple(args, ":GetConfig"))
     431        return NULL;
     432
     433    if ((par = (*func)(self->config)) == -1)
     434        return NULL;
     435
     436    return PyInt_FromLong((long) par);
    437437}
    438438
    … …  
    440440alc_setqueuesize (alcobject *self, PyObject *args)
    441441{
    442         return setconfig(self, args, ALsetqueuesize);
     442    return setconfig(self, args, ALsetqueuesize);
    443443}
    444444
    … …  
    446446alc_getqueuesize (alcobject *self, PyObject *args)
    447447{
    448         return getconfig(self, args, ALgetqueuesize);
     448    return getconfig(self, args, ALgetqueuesize);
    449449}
    450450
    … …  
    452452alc_setwidth (alcobject *self, PyObject *args)
    453453{
    454         return setconfig(self, args, ALsetwidth);
     454    return setconfig(self, args, ALsetwidth);
    455455}
    456456
    … …  
    458458alc_getwidth (alcobject *self, PyObject *args)
    459459{
    460         return getconfig(self, args, ALgetwidth);       
     460    return getconfig(self, args, ALgetwidth);
    461461}
    462462
    … …  
    464464alc_getchannels (alcobject *self, PyObject *args)
    465465{
    466         return getconfig(self, args, ALgetchannels);   
     466    return getconfig(self, args, ALgetchannels);
    467467}
    468468
    … …  
    470470alc_setchannels (alcobject *self, PyObject *args)
    471471{
    472         return setconfig(self, args, ALsetchannels);
     472    return setconfig(self, args, ALsetchannels);
    473473}
    474474
    … …  
    478478alc_getsampfmt (alcobject *self, PyObject *args)
    479479{
    480         return getconfig(self, args, ALgetsampfmt);     
     480    return getconfig(self, args, ALgetsampfmt);
    481481}
    482482
    … …  
    484484alc_setsampfmt (alcobject *self, PyObject *args)
    485485{
    486         return setconfig(self, args, ALsetsampfmt);
     486    return setconfig(self, args, ALsetsampfmt);
    487487}
    488488
    … …  
    490490alc_getfloatmax(alcobject *self, PyObject *args)
    491491{
    492         double arg;
    493 
    494         if (!PyArg_ParseTuple(args, ":GetFloatMax"))
    495                 return 0;
    496         if ((arg = ALgetfloatmax(self->config)) == 0)
    497                 return NULL;
    498         return PyFloat_FromDouble(arg);
     492    double arg;
     493
     494    if (!PyArg_ParseTuple(args, ":GetFloatMax"))
     495        return 0;
     496    if ((arg = ALgetfloatmax(self->config)) == 0)
     497        return NULL;
     498    return PyFloat_FromDouble(arg);
    499499}
    500500
    … …  
    502502alc_setfloatmax(alcobject *self, PyObject *args)
    503503{
    504         double arg;
    505 
    506         if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
    507                 return 0;
    508         if (ALsetfloatmax(self->config, arg) == -1)
    509                 return NULL;
    510         Py_INCREF(Py_None);
    511         return Py_None;
     504    double arg;
     505
     506    if (!PyArg_ParseTuple(args, "d:SetFloatMax", &arg))
     507        return 0;
     508    if (ALsetfloatmax(self->config, arg) == -1)
     509        return NULL;
     510    Py_INCREF(Py_None);
     511    return Py_None;
    512512}
    513513#endif /* AL_405 */
    514        
     514
    515515static struct PyMethodDef alc_methods[] = {
    516 #ifdef AL_NO_ELEM               /* IRIX 6 */
    517         {"SetWidth",    (PyCFunction)alc_SetWidth,      METH_VARARGS,   alc_SetWidth__doc__},
    518         {"GetWidth",    (PyCFunction)alc_GetWidth,      METH_VARARGS,   alc_GetWidth__doc__},
    519         {"SetSampFmt",  (PyCFunction)alc_SetSampFmt,    METH_VARARGS,   alc_SetSampFmt__doc__},
    520         {"GetSampFmt",  (PyCFunction)alc_GetSampFmt,    METH_VARARGS,   alc_GetSampFmt__doc__},
    521         {"SetChannels", (PyCFunction)alc_SetChannels,   METH_VARARGS,   alc_SetChannels__doc__},
    522         {"GetChannels", (PyCFunction)alc_GetChannels,   METH_VARARGS,   alc_GetChannels__doc__},
    523         {"SetFloatMax", (PyCFunction)alc_SetFloatMax,   METH_VARARGS,   alc_SetFloatMax__doc__},
    524         {"GetFloatMax", (PyCFunction)alc_GetFloatMax,   METH_VARARGS,   alc_GetFloatMax__doc__},
    525         {"SetDevice",   (PyCFunction)alc_SetDevice,     METH_VARARGS,   alc_SetDevice__doc__},
    526         {"GetDevice",   (PyCFunction)alc_GetDevice,     METH_VARARGS,   alc_GetDevice__doc__},
    527         {"SetQueueSize",        (PyCFunction)alc_SetQueueSize,  METH_VARARGS,   alc_SetQueueSize__doc__},
    528         {"GetQueueSize",        (PyCFunction)alc_GetQueueSize,  METH_VARARGS,   alc_GetQueueSize__doc__},
     516#ifdef AL_NO_ELEM               /* IRIX 6 */
     517    {"SetWidth",        (PyCFunction)alc_SetWidth,      METH_VARARGS,   alc_SetWidth__doc__},
     518    {"GetWidth",        (PyCFunction)alc_GetWidth,      METH_VARARGS,   alc_GetWidth__doc__},
     519    {"SetSampFmt",      (PyCFunction)alc_SetSampFmt,    METH_VARARGS,   alc_SetSampFmt__doc__},
     520    {"GetSampFmt",      (PyCFunction)alc_GetSampFmt,    METH_VARARGS,   alc_GetSampFmt__doc__},
     521    {"SetChannels",     (PyCFunction)alc_SetChannels,   METH_VARARGS,   alc_SetChannels__doc__},
     522    {"GetChannels",     (PyCFunction)alc_GetChannels,   METH_VARARGS,   alc_GetChannels__doc__},
     523    {"SetFloatMax",     (PyCFunction)alc_SetFloatMax,   METH_VARARGS,   alc_SetFloatMax__doc__},
     524    {"GetFloatMax",     (PyCFunction)alc_GetFloatMax,   METH_VARARGS,   alc_GetFloatMax__doc__},
     525    {"SetDevice",       (PyCFunction)alc_SetDevice,     METH_VARARGS,   alc_SetDevice__doc__},
     526    {"GetDevice",       (PyCFunction)alc_GetDevice,     METH_VARARGS,   alc_GetDevice__doc__},
     527    {"SetQueueSize",            (PyCFunction)alc_SetQueueSize,  METH_VARARGS,   alc_SetQueueSize__doc__},
     528    {"GetQueueSize",            (PyCFunction)alc_GetQueueSize,  METH_VARARGS,   alc_GetQueueSize__doc__},
    529529#endif /* AL_NO_ELEM */
    530         {"getqueuesize",        (PyCFunction)alc_getqueuesize,  METH_VARARGS},
    531         {"setqueuesize",        (PyCFunction)alc_setqueuesize,  METH_VARARGS},
    532         {"getwidth",            (PyCFunction)alc_getwidth,      METH_VARARGS},
    533         {"setwidth",            (PyCFunction)alc_setwidth,      METH_VARARGS},
    534         {"getchannels",         (PyCFunction)alc_getchannels,   METH_VARARGS},
    535         {"setchannels",         (PyCFunction)alc_setchannels,   METH_VARARGS},
     530    {"getqueuesize",            (PyCFunction)alc_getqueuesize,  METH_VARARGS},
     531    {"setqueuesize",            (PyCFunction)alc_setqueuesize,  METH_VARARGS},
     532    {"getwidth",                (PyCFunction)alc_getwidth,      METH_VARARGS},
     533    {"setwidth",                (PyCFunction)alc_setwidth,      METH_VARARGS},
     534    {"getchannels",             (PyCFunction)alc_getchannels,   METH_VARARGS},
     535    {"setchannels",             (PyCFunction)alc_setchannels,   METH_VARARGS},
    536536#ifdef AL_405
    537         {"getsampfmt",          (PyCFunction)alc_getsampfmt,    METH_VARARGS},
    538         {"setsampfmt",          (PyCFunction)alc_setsampfmt,    METH_VARARGS},
    539         {"getfloatmax",         (PyCFunction)alc_getfloatmax,   METH_VARARGS},
    540         {"setfloatmax",         (PyCFunction)alc_setfloatmax,   METH_VARARGS},
     537    {"getsampfmt",              (PyCFunction)alc_getsampfmt,    METH_VARARGS},
     538    {"setsampfmt",              (PyCFunction)alc_setsampfmt,    METH_VARARGS},
     539    {"getfloatmax",             (PyCFunction)alc_getfloatmax,   METH_VARARGS},
     540    {"setfloatmax",             (PyCFunction)alc_setfloatmax,   METH_VARARGS},
    541541#endif /* AL_405 */
    542542
    543         {NULL,          NULL}           /* sentinel */
     543    {NULL,              NULL}           /* sentinel */
    544544};
    545545
    … …  
    550550newalcobject(ALconfig config)
    551551{
    552         alcobject *self;
    553        
    554         self = PyObject_New(alcobject, &Alctype);
    555         if (self == NULL)
    556                 return NULL;
    557         /* XXXX Add your own initializers here */
    558         self->config = config;
    559         return (PyObject *) self;
     552    alcobject *self;
     553
     554    self = PyObject_New(alcobject, &Alctype);
     555    if (self == NULL)
     556        return NULL;
     557    /* XXXX Add your own initializers here */
     558    self->config = config;
     559    return (PyObject *) self;
    560560}
    561561
    … …  
    564564alc_dealloc(alcobject *self)
    565565{
    566         /* XXXX Add your own cleanup code here */
    567 #ifdef AL_NO_ELEM               /* IRIX 6 */
    568         (void) alFreeConfig(self->config);      /* ignore errors */
     566    /* XXXX Add your own cleanup code here */
     567#ifdef AL_NO_ELEM               /* IRIX 6 */
     568    (void) alFreeConfig(self->config);          /* ignore errors */
    569569#else
    570         (void) ALfreeconfig(self->config);      /* ignore errors */
    571 #endif
    572         PyObject_Del(self);
     570    (void) ALfreeconfig(self->config);          /* ignore errors */
     571#endif
     572    PyObject_Del(self);
    573573}
    574574
    … …  
    576576alc_getattr(alcobject *self, char *name)
    577577{
    578         /* XXXX Add your own getattr code here */
    579         return Py_FindMethod(alc_methods, (PyObject *)self, name);
     578    /* XXXX Add your own getattr code here */
     579    return Py_FindMethod(alc_methods, (PyObject *)self, name);
    580580}
    581581
    … …  
    583583
    584584static PyTypeObject Alctype = {
    585         PyObject_HEAD_INIT(&PyType_Type)
    586         0,                              /*ob_size*/
    587         "al.config",                    /*tp_name*/
    588         sizeof(alcobject),              /*tp_basicsize*/
    589         0,                              /*tp_itemsize*/
    590         /* methods */
    591         (destructor)alc_dealloc,        /*tp_dealloc*/
    592         (printfunc)0,           /*tp_print*/
    593         (getattrfunc)alc_getattr,       /*tp_getattr*/
    594         (setattrfunc)0, /*tp_setattr*/
    595         (cmpfunc)0,             /*tp_compare*/
    596         (reprfunc)0,            /*tp_repr*/
    597         0,                      /*tp_as_number*/
    598         0,              /*tp_as_sequence*/
    599         0,              /*tp_as_mapping*/
    600         (hashfunc)0,            /*tp_hash*/
    601         (ternaryfunc)0,         /*tp_call*/
    602         (reprfunc)0,            /*tp_str*/
    603 
    604         /* Space for future expansion */
    605         0L,0L,0L,0L,
    606         Alctype__doc__ /* Documentation string */
     585    PyObject_HEAD_INIT(&PyType_Type)
     586    0,                                  /*ob_size*/
     587    "al.config",                        /*tp_name*/
     588    sizeof(alcobject),                  /*tp_basicsize*/
     589    0,                                  /*tp_itemsize*/
     590    /* methods */
     591    (destructor)alc_dealloc,            /*tp_dealloc*/
     592    (printfunc)0,               /*tp_print*/
     593    (getattrfunc)alc_getattr,           /*tp_getattr*/
     594    (setattrfunc)0,     /*tp_setattr*/
     595    (cmpfunc)0,                 /*tp_compare*/
     596    (reprfunc)0,                /*tp_repr*/
     597    0,                          /*tp_as_number*/
     598    0,                  /*tp_as_sequence*/
     599    0,                  /*tp_as_mapping*/
     600    (hashfunc)0,                /*tp_hash*/
     601    (ternaryfunc)0,             /*tp_call*/
     602    (reprfunc)0,                /*tp_str*/
     603
     604    /* Space for future expansion */
     605    0L,0L,0L,0L,
     606    Alctype__doc__ /* Documentation string */
    607607};
    608608
    … …  
    610610/* ---------------------------------------------------------------- */
    611611
    612 #ifdef AL_NO_ELEM               /* IRIX 6 */
     612#ifdef AL_NO_ELEM               /* IRIX 6 */
    613613
    614614PyDoc_STRVAR(alp_SetConfig__doc__,
    … …  
    618618alp_SetConfig(alpobject *self, PyObject *args)
    619619{
    620         alcobject *config;
    621         if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
    622                 return NULL;
    623         if (alSetConfig(self->port, config->config) < 0)
    624                 return NULL;
    625         Py_INCREF(Py_None);
    626         return Py_None;
     620    alcobject *config;
     621    if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
     622        return NULL;
     623    if (alSetConfig(self->port, config->config) < 0)
     624        return NULL;
     625    Py_INCREF(Py_None);
     626    return Py_None;
    627627}
    628628
    … …  
    634634alp_GetConfig(alpobject *self, PyObject *args)
    635635{
    636         ALconfig config;
    637         if (!PyArg_ParseTuple(args, ":GetConfig"))
    638                 return NULL;
    639         if ((config = alGetConfig(self->port)) == NULL)
    640                 return NULL;
    641         return newalcobject(config);
     636    ALconfig config;
     637    if (!PyArg_ParseTuple(args, ":GetConfig"))
     638        return NULL;
     639    if ((config = alGetConfig(self->port)) == NULL)
     640        return NULL;
     641    return newalcobject(config);
    642642}
    643643
    … …  
    649649alp_GetResource(alpobject *self, PyObject *args)
    650650{
    651         int resource;
    652 
    653         if (!PyArg_ParseTuple(args, ":GetResource"))
    654                 return NULL;
    655         if ((resource = alGetResource(self->port)) == 0)
    656                 return NULL;
    657         return PyInt_FromLong((long) resource);
     651    int resource;
     652
     653    if (!PyArg_ParseTuple(args, ":GetResource"))
     654        return NULL;
     655    if ((resource = alGetResource(self->port)) == 0)
     656        return NULL;
     657    return PyInt_FromLong((long) resource);
    658658}
    659659
    … …  
    665665alp_GetFD(alpobject *self, PyObject *args)
    666666{
    667         int fd;
    668 
    669         if (!PyArg_ParseTuple(args, ":GetFD"))
    670                 return NULL;
    671 
    672         if ((fd = alGetFD(self->port)) < 0)
    673                 return NULL;
    674 
    675         return PyInt_FromLong((long) fd);
     667    int fd;
     668
     669    if (!PyArg_ParseTuple(args, ":GetFD"))
     670        return NULL;
     671
     672    if ((fd = alGetFD(self->port)) < 0)
     673        return NULL;
     674
     675    return PyInt_FromLong((long) fd);
    676676}
    677677
    … …  
    684684alp_GetFilled(alpobject *self, PyObject *args)
    685685{
    686         int filled;
    687 
    688         if (!PyArg_ParseTuple(args, ":GetFilled"))
    689                 return NULL;
    690         if ((filled = alGetFilled(self->port)) < 0)
    691                 return NULL;
    692         return PyInt_FromLong((long) filled);
     686    int filled;
     687
     688    if (!PyArg_ParseTuple(args, ":GetFilled"))
     689        return NULL;
     690    if ((filled = alGetFilled(self->port)) < 0)
     691        return NULL;
     692    return PyInt_FromLong((long) filled);
    693693}
    694694
    … …  
    701701alp_GetFillable(alpobject *self, PyObject *args)
    702702{
    703         int fillable;
    704 
    705         if (!PyArg_ParseTuple(args, ":GetFillable"))
    706                 return NULL;
    707         if ((fillable = alGetFillable(self->port)) < 0)
    708                 return NULL;
    709         return PyInt_FromLong((long) fillable);
     703    int fillable;
     704
     705    if (!PyArg_ParseTuple(args, ":GetFillable"))
     706        return NULL;
     707    if ((fillable = alGetFillable(self->port)) < 0)
     708        return NULL;
     709    return PyInt_FromLong((long) fillable);
    710710}
    711711
    … …  
    717717alp_ReadFrames(alpobject *self, PyObject *args)
    718718{
    719         int framecount;
    720         PyObject *v;
    721         int size;
    722         int ch;
    723         ALconfig c;
    724 
    725         if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
    726                 return NULL;
    727         if (framecount < 0) {
    728                 PyErr_SetString(ErrorObject, "negative framecount");
    729                 return NULL;
    730         }
    731         c = alGetConfig(self->port);
    732         switch (alGetSampFmt(c)) {
    733         case AL_SAMPFMT_TWOSCOMP:
    734                 switch (alGetWidth(c)) {
    735                 case AL_SAMPLE_8:
    736                         size = 1;
    737                         break;
    738                 case AL_SAMPLE_16:
    739                         size = 2;
    740                         break;
    741                 case AL_SAMPLE_24:
    742                         size = 4;
    743                         break;
    744                 default:
    745                         PyErr_SetString(ErrorObject, "can't determine width");
    746                         alFreeConfig(c);
    747                         return NULL;
    748                 }
    749                 break;
    750         case AL_SAMPFMT_FLOAT:
    751                 size = 4;
    752                 break;
    753         case AL_SAMPFMT_DOUBLE:
    754                 size = 8;
    755                 break;
    756         default:
    757                 PyErr_SetString(ErrorObject, "can't determine format");
    758                 alFreeConfig(c);
    759                 return NULL;
    760         }
    761         ch = alGetChannels(c);
    762         alFreeConfig(c);
    763         if (ch < 0) {
    764                 PyErr_SetString(ErrorObject, "can't determine # of channels");
    765                 return NULL;
    766         }
    767         size *= ch;
    768         v = PyString_FromStringAndSize((char *) NULL, size * framecount);
    769         if (v == NULL)
    770                 return NULL;
    771 
    772         Py_BEGIN_ALLOW_THREADS
    773         alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
    774         Py_END_ALLOW_THREADS
    775 
    776         return v;
     719    int framecount;
     720    PyObject *v;
     721    int size;
     722    int ch;
     723    ALconfig c;
     724
     725    if (!PyArg_ParseTuple(args, "i:ReadFrames", &framecount))
     726        return NULL;
     727    if (framecount < 0) {
     728        PyErr_SetString(ErrorObject, "negative framecount");
     729        return NULL;
     730    }
     731    c = alGetConfig(self->port);
     732    switch (alGetSampFmt(c)) {
     733    case AL_SAMPFMT_TWOSCOMP:
     734        switch (alGetWidth(c)) {
     735        case AL_SAMPLE_8:
     736            size = 1;
     737            break;
     738        case AL_SAMPLE_16:
     739            size = 2;
     740            break;
     741        case AL_SAMPLE_24:
     742            size = 4;
     743            break;
     744        default:
     745            PyErr_SetString(ErrorObject, "can't determine width");
     746            alFreeConfig(c);
     747            return NULL;
     748        }
     749        break;
     750    case AL_SAMPFMT_FLOAT:
     751        size = 4;
     752        break;
     753    case AL_SAMPFMT_DOUBLE:
     754        size = 8;
     755        break;
     756    default:
     757        PyErr_SetString(ErrorObject, "can't determine format");
     758        alFreeConfig(c);
     759        return NULL;
     760    }
     761    ch = alGetChannels(c);
     762    alFreeConfig(c);
     763    if (ch < 0) {
     764        PyErr_SetString(ErrorObject, "can't determine # of channels");
     765        return NULL;
     766    }
     767    size *= ch;
     768    v = PyString_FromStringAndSize((char *) NULL, size * framecount);
     769    if (v == NULL)
     770        return NULL;
     771
     772    Py_BEGIN_ALLOW_THREADS
     773    alReadFrames(self->port, (void *) PyString_AS_STRING(v), framecount);
     774    Py_END_ALLOW_THREADS
     775
     776    return v;
    777777}
    778778
    … …  
    784784alp_DiscardFrames(alpobject *self, PyObject *args)
    785785{
    786         int framecount;
    787 
    788         if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
    789                 return NULL;
    790 
    791         Py_BEGIN_ALLOW_THREADS
    792         framecount = alDiscardFrames(self->port, framecount);
    793         Py_END_ALLOW_THREADS
    794 
    795         if (framecount < 0)
    796                 return NULL;
    797 
    798         return PyInt_FromLong((long) framecount);
     786    int framecount;
     787
     788    if (!PyArg_ParseTuple(args, "i:DiscardFrames", &framecount))
     789        return NULL;
     790
     791    Py_BEGIN_ALLOW_THREADS
     792    framecount = alDiscardFrames(self->port, framecount);
     793    Py_END_ALLOW_THREADS
     794
     795    if (framecount < 0)
     796        return NULL;
     797
     798    return PyInt_FromLong((long) framecount);
    799799}
    800800
    … …  
    806806alp_ZeroFrames(alpobject *self, PyObject *args)
    807807{
    808         int framecount;
    809 
    810         if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
    811                 return NULL;
    812 
    813         if (framecount < 0) {
    814                 PyErr_SetString(ErrorObject, "negative framecount");
    815                 return NULL;
    816         }
    817 
    818         Py_BEGIN_ALLOW_THREADS
    819         alZeroFrames(self->port, framecount);
    820         Py_END_ALLOW_THREADS
    821 
    822         Py_INCREF(Py_None);
    823         return Py_None;
     808    int framecount;
     809
     810    if (!PyArg_ParseTuple(args, "i:ZeroFrames", &framecount))
     811        return NULL;
     812
     813    if (framecount < 0) {
     814        PyErr_SetString(ErrorObject, "negative framecount");
     815        return NULL;
     816    }
     817
     818    Py_BEGIN_ALLOW_THREADS
     819    alZeroFrames(self->port, framecount);
     820    Py_END_ALLOW_THREADS
     821
     822    Py_INCREF(Py_None);
     823    return Py_None;
    824824}
    825825
    … …  
    831831alp_SetFillPoint(alpobject *self, PyObject *args)
    832832{
    833         int fillpoint;
    834 
    835         if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
    836                 return NULL;
    837 
    838         if (alSetFillPoint(self->port, fillpoint) < 0)
    839                 return NULL;
    840 
    841         Py_INCREF(Py_None);
    842         return Py_None;
     833    int fillpoint;
     834
     835    if (!PyArg_ParseTuple(args, "i:SetFillPoint", &fillpoint))
     836        return NULL;
     837
     838    if (alSetFillPoint(self->port, fillpoint) < 0)
     839        return NULL;
     840
     841    Py_INCREF(Py_None);
     842    return Py_None;
    843843}
    844844
    … …  
    850850alp_GetFillPoint(alpobject *self, PyObject *args)
    851851{
    852         int fillpoint;
    853 
    854         if (!PyArg_ParseTuple(args, ":GetFillPoint"))
    855                 return NULL;
    856 
    857         if ((fillpoint = alGetFillPoint(self->port)) < 0)
    858                 return NULL;
    859 
    860         return PyInt_FromLong((long) fillpoint);
     852    int fillpoint;
     853
     854    if (!PyArg_ParseTuple(args, ":GetFillPoint"))
     855        return NULL;
     856
     857    if ((fillpoint = alGetFillPoint(self->port)) < 0)
     858        return NULL;
     859
     860    return PyInt_FromLong((long) fillpoint);
    861861}
    862862
    … …  
    869869alp_GetFrameNumber(alpobject *self, PyObject *args)
    870870{
    871         stamp_t fnum;
    872 
    873         if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
    874                 return NULL;
    875 
    876         if (alGetFrameNumber(self->port, &fnum) < 0)
    877                 return NULL;
    878 
    879         return PyLong_FromLongLong((long long) fnum);
     871    stamp_t fnum;
     872
     873    if (!PyArg_ParseTuple(args, ":GetFrameNumber"))
     874        return NULL;
     875
     876    if (alGetFrameNumber(self->port, &fnum) < 0)
     877        return NULL;
     878
     879    return PyLong_FromLongLong((long long) fnum);
    880880}
    881881
    … …  
    888888alp_GetFrameTime(alpobject *self, PyObject *args)
    889889{
    890         stamp_t fnum, time;
    891         PyObject *ret, *v0, *v1;
    892 
    893         if (!PyArg_ParseTuple(args, ":GetFrameTime"))
    894                 return NULL;
    895         if (alGetFrameTime(self->port, &fnum, &time) < 0)
    896                 return NULL;
    897         v0 = PyLong_FromLongLong((long long) fnum);
    898         v1 = PyLong_FromLongLong((long long) time);
    899         if (PyErr_Occurred()) {
    900                 Py_XDECREF(v0);
    901                 Py_XDECREF(v1);
    902                 return NULL;
    903         }
    904         ret = PyTuple_Pack(2, v0, v1);
    905         Py_DECREF(v0);
    906         Py_DECREF(v1);
    907         return ret;
     890    stamp_t fnum, time;
     891    PyObject *ret, *v0, *v1;
     892
     893    if (!PyArg_ParseTuple(args, ":GetFrameTime"))
     894        return NULL;
     895    if (alGetFrameTime(self->port, &fnum, &time) < 0)
     896        return NULL;
     897    v0 = PyLong_FromLongLong((long long) fnum);
     898    v1 = PyLong_FromLongLong((long long) time);
     899    if (PyErr_Occurred()) {
     900        Py_XDECREF(v0);
     901        Py_XDECREF(v1);
     902        return NULL;
     903    }
     904    ret = PyTuple_Pack(2, v0, v1);
     905    Py_DECREF(v0);
     906    Py_DECREF(v1);
     907    return ret;
    908908}
    909909
    … …  
    915915alp_WriteFrames(alpobject *self, PyObject *args)
    916916{
    917         char *samples;
    918         int length;
    919         int size, ch;
    920         ALconfig c;
    921 
    922         if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
    923                 return NULL;
    924         c = alGetConfig(self->port);
    925         switch (alGetSampFmt(c)) {
    926         case AL_SAMPFMT_TWOSCOMP:
    927                 switch (alGetWidth(c)) {
    928                 case AL_SAMPLE_8:
    929                         size = 1;
    930                         break;
    931                 case AL_SAMPLE_16:
    932                         size = 2;
    933                         break;
    934                 case AL_SAMPLE_24:
    935                         size = 4;
    936                         break;
    937                 default:
    938                         PyErr_SetString(ErrorObject, "can't determine width");
    939                         alFreeConfig(c);
    940                         return NULL;
    941                 }
    942                 break;
    943         case AL_SAMPFMT_FLOAT:
    944                 size = 4;
    945                 break;
    946         case AL_SAMPFMT_DOUBLE:
    947                 size = 8;
    948                 break;
    949         default:
    950                 PyErr_SetString(ErrorObject, "can't determine format");
    951                 alFreeConfig(c);
    952                 return NULL;
    953         }
    954         ch = alGetChannels(c);
    955         alFreeConfig(c);
    956         if (ch < 0) {
    957                 PyErr_SetString(ErrorObject, "can't determine # of channels");
    958                 return NULL;
    959         }
    960         size *= ch;
    961         if (length % size != 0) {
    962                 PyErr_SetString(ErrorObject,
    963                                 "buffer length not whole number of frames");
    964                 return NULL;
    965         }
    966 
    967         Py_BEGIN_ALLOW_THREADS
    968         alWriteFrames(self->port, (void *) samples, length / size);
    969         Py_END_ALLOW_THREADS
    970 
    971         Py_INCREF(Py_None);
    972         return Py_None;
     917    char *samples;
     918    int length;
     919    int size, ch;
     920    ALconfig c;
     921
     922    if (!PyArg_ParseTuple(args, "s#:WriteFrames", &samples, &length))
     923        return NULL;
     924    c = alGetConfig(self->port);
     925    switch (alGetSampFmt(c)) {
     926    case AL_SAMPFMT_TWOSCOMP:
     927        switch (alGetWidth(c)) {
     928        case AL_SAMPLE_8:
     929            size = 1;
     930            break;
     931        case AL_SAMPLE_16:
     932            size = 2;
     933            break;
     934        case AL_SAMPLE_24:
     935            size = 4;
     936            break;
     937        default:
     938            PyErr_SetString(ErrorObject, "can't determine width");
     939            alFreeConfig(c);
     940            return NULL;
     941        }
     942        break;
     943    case AL_SAMPFMT_FLOAT:
     944        size = 4;
     945        break;
     946    case AL_SAMPFMT_DOUBLE:
     947        size = 8;
     948        break;
     949    default:
     950        PyErr_SetString(ErrorObject, "can't determine format");
     951        alFreeConfig(c);
     952        return NULL;
     953    }
     954    ch = alGetChannels(c);
     955    alFreeConfig(c);
     956    if (ch < 0) {
     957        PyErr_SetString(ErrorObject, "can't determine # of channels");
     958        return NULL;
     959    }
     960    size *= ch;
     961    if (length % size != 0) {
     962        PyErr_SetString(ErrorObject,
     963                        "buffer length not whole number of frames");
     964        return NULL;
     965    }
     966
     967    Py_BEGIN_ALLOW_THREADS
     968    alWriteFrames(self->port, (void *) samples, length / size);
     969    Py_END_ALLOW_THREADS
     970
     971    Py_INCREF(Py_None);
     972    return Py_None;
    973973}
    974974
    … …  
    979979alp_ClosePort(alpobject *self, PyObject *args)
    980980{
    981         if (!PyArg_ParseTuple(args, ":ClosePort"))
    982                 return NULL;
    983         if (alClosePort(self->port) < 0)
    984                 return NULL;
    985         self->port = NULL;
    986         Py_INCREF(Py_None);
    987         return Py_None;
     981    if (!PyArg_ParseTuple(args, ":ClosePort"))
     982        return NULL;
     983    if (alClosePort(self->port) < 0)
     984        return NULL;
     985    self->port = NULL;
     986    Py_INCREF(Py_None);
     987    return Py_None;
    988988}
    989989
    … …  
    994994alp_closeport(alpobject *self, PyObject *args)
    995995{
    996         if (!PyArg_ParseTuple(args, ":ClosePort"))
    997                 return NULL;
    998         if (ALcloseport(self->port) < 0)
    999                 return NULL;
    1000         self->port = NULL;
    1001         Py_INCREF(Py_None);
    1002         return Py_None;
     996    if (!PyArg_ParseTuple(args, ":ClosePort"))
     997        return NULL;
     998    if (ALcloseport(self->port) < 0)
     999        return NULL;
     1000    self->port = NULL;
     1001    Py_INCREF(Py_None);
     1002    return Py_None;
    10031003}
    10041004
    … …  
    10061006alp_getfd(alpobject *self, PyObject *args)
    10071007{
    1008         int fd;
    1009 
    1010         if (!PyArg_ParseTuple(args, ":GetFD"))
    1011                 return NULL;
    1012         if ((fd = ALgetfd(self-> port)) == -1)
    1013                 return NULL;
    1014         return PyInt_FromLong(fd);
     1008    int fd;
     1009
     1010    if (!PyArg_ParseTuple(args, ":GetFD"))
     1011        return NULL;
     1012    if ((fd = ALgetfd(self-> port)) == -1)
     1013        return NULL;
     1014    return PyInt_FromLong(fd);
    10151015}
    10161016
    … …  
    10181018alp_getfilled(alpobject *self, PyObject *args)
    10191019{
    1020         long count;
    1021 
    1022         if (!PyArg_ParseTuple(args, ":GetFilled"))
    1023                 return NULL;
    1024         if ((count = ALgetfilled(self-> port)) == -1)
    1025                 return NULL;
    1026         return PyInt_FromLong(count);
     1020    long count;
     1021
     1022    if (!PyArg_ParseTuple(args, ":GetFilled"))
     1023        return NULL;
     1024    if ((count = ALgetfilled(self-> port)) == -1)
     1025        return NULL;
     1026    return PyInt_FromLong(count);
    10271027}
    10281028
    … …  
    10301030alp_getfillable(alpobject *self, PyObject *args)
    10311031{
    1032         long count;
    1033 
    1034         if (!PyArg_ParseTuple(args, ":GetFillable"))
    1035                 return NULL;
    1036         if ((count = ALgetfillable(self-> port)) == -1)
    1037                 return NULL;
    1038         return PyInt_FromLong (count);
     1032    long count;
     1033
     1034    if (!PyArg_ParseTuple(args, ":GetFillable"))
     1035        return NULL;
     1036    if ((count = ALgetfillable(self-> port)) == -1)
     1037        return NULL;
     1038    return PyInt_FromLong (count);
    10391039}
    10401040
    … …  
    10421042alp_readsamps(alpobject *self, PyObject *args)
    10431043{
    1044         long count;
    1045         PyObject *v;
    1046         ALconfig c;
    1047         int width;
    1048         int ret;
    1049 
    1050         if (!PyArg_ParseTuple(args, "l:readsamps", &count))
    1051                 return NULL;
    1052 
    1053         if (count <= 0) {
    1054                 PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
    1055                 return NULL;
    1056         }
    1057 
    1058         c = ALgetconfig(self->port);
     1044    long count;
     1045    PyObject *v;
     1046    ALconfig c;
     1047    int width;
     1048    int ret;
     1049
     1050    if (!PyArg_ParseTuple(args, "l:readsamps", &count))
     1051        return NULL;
     1052
     1053    if (count <= 0) {
     1054        PyErr_SetString(ErrorObject, "al.readsamps : arg <= 0");
     1055        return NULL;
     1056    }
     1057
     1058    c = ALgetconfig(self->port);
    10591059#ifdef AL_405
    1060         width = ALgetsampfmt(c);
    1061         if (width == AL_SAMPFMT_FLOAT)
    1062                 width = sizeof(float);
    1063         else if (width == AL_SAMPFMT_DOUBLE)
    1064                 width = sizeof(double);
    1065         else
    1066                 width = ALgetwidth(c);
     1060    width = ALgetsampfmt(c);
     1061    if (width == AL_SAMPFMT_FLOAT)
     1062        width = sizeof(float);
     1063    else if (width == AL_SAMPFMT_DOUBLE)
     1064        width = sizeof(double);
     1065    else
     1066        width = ALgetwidth(c);
    10671067#else
    1068         width = ALgetwidth(c);
     1068    width = ALgetwidth(c);
    10691069#endif /* AL_405 */
    1070         ALfreeconfig(c);
    1071         v = PyString_FromStringAndSize((char *)NULL, width * count);
    1072         if (v == NULL)
    1073                 return NULL;
    1074 
    1075         Py_BEGIN_ALLOW_THREADS
    1076         ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
    1077         Py_END_ALLOW_THREADS
    1078         if (ret == -1) {
    1079                 Py_DECREF(v);
    1080                 return NULL;
    1081         }
    1082 
    1083         return (v);
     1070    ALfreeconfig(c);
     1071    v = PyString_FromStringAndSize((char *)NULL, width * count);
     1072    if (v == NULL)
     1073        return NULL;
     1074
     1075    Py_BEGIN_ALLOW_THREADS
     1076    ret = ALreadsamps(self->port, (void *) PyString_AsString(v), count);
     1077    Py_END_ALLOW_THREADS
     1078    if (ret == -1) {
     1079        Py_DECREF(v);
     1080        return NULL;
     1081    }
     1082
     1083    return (v);
    10841084}
    10851085
    … …  
    10871087alp_writesamps(alpobject *self, PyObject *args)
    10881088{
    1089         char *buf;
    1090         int size, width;
    1091         ALconfig c;
    1092         int ret;
    1093 
    1094         if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
    1095                 return NULL;
    1096 
    1097         c = ALgetconfig(self->port);
     1089    char *buf;
     1090    int size, width;
     1091    ALconfig c;
     1092    int ret;
     1093
     1094    if (!PyArg_ParseTuple(args, "s#:writesamps", &buf, &size))
     1095        return NULL;
     1096
     1097    c = ALgetconfig(self->port);
    10981098#ifdef AL_405
    1099         width = ALgetsampfmt(c);
    1100         if (width == AL_SAMPFMT_FLOAT)
    1101                 width = sizeof(float);
    1102         else if (width == AL_SAMPFMT_DOUBLE)
    1103                 width = sizeof(double);
    1104         else
    1105                 width = ALgetwidth(c);
     1099    width = ALgetsampfmt(c);
     1100    if (width == AL_SAMPFMT_FLOAT)
     1101        width = sizeof(float);
     1102    else if (width == AL_SAMPFMT_DOUBLE)
     1103        width = sizeof(double);
     1104    else
     1105        width = ALgetwidth(c);
    11061106#else
    1107         width = ALgetwidth(c);
     1107    width = ALgetwidth(c);
    11081108#endif /* AL_405 */
    1109         ALfreeconfig(c);
    1110         Py_BEGIN_ALLOW_THREADS
    1111         ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
    1112         Py_END_ALLOW_THREADS
    1113         if (ret == -1)
    1114                 return NULL;
    1115 
    1116         Py_INCREF(Py_None);
    1117         return Py_None;
     1109    ALfreeconfig(c);
     1110    Py_BEGIN_ALLOW_THREADS
     1111    ret = ALwritesamps (self->port, (void *) buf, (long) size / width);
     1112    Py_END_ALLOW_THREADS
     1113    if (ret == -1)
     1114        return NULL;
     1115
     1116    Py_INCREF(Py_None);
     1117    return Py_None;
    11181118}
    11191119
    … …  
    11211121alp_getfillpoint(alpobject *self, PyObject *args)
    11221122{
    1123         long count;
    1124 
    1125         if (!PyArg_ParseTuple(args, ":GetFillPoint"))
    1126                 return NULL;
    1127         if ((count = ALgetfillpoint(self->port)) == -1)
    1128                 return NULL;
    1129         return PyInt_FromLong(count);
     1123    long count;
     1124
     1125    if (!PyArg_ParseTuple(args, ":GetFillPoint"))
     1126        return NULL;
     1127    if ((count = ALgetfillpoint(self->port)) == -1)
     1128        return NULL;
     1129    return PyInt_FromLong(count);
    11301130}
    11311131
    … …  
    11331133alp_setfillpoint(alpobject *self, PyObject *args)
    11341134{
    1135         long count;
    1136 
    1137         if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
    1138                 return NULL;
    1139         if (ALsetfillpoint(self->port, count) == -1)
    1140                 return NULL;
    1141         Py_INCREF(Py_None);
    1142         return Py_None;
     1135    long count;
     1136
     1137    if (!PyArg_ParseTuple(args, "l:SetFillPoint", &count))
     1138        return NULL;
     1139    if (ALsetfillpoint(self->port, count) == -1)
     1140        return NULL;
     1141    Py_INCREF(Py_None);
     1142    return Py_None;
    11431143}
    11441144
    … …  
    11461146alp_setconfig(alpobject *self, PyObject *args)
    11471147{
    1148         alcobject *config;
    1149 
    1150         if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
    1151                 return NULL;
    1152         if (ALsetconfig(self->port, config->config) == -1)
    1153                 return NULL;
    1154         Py_INCREF(Py_None);
    1155         return Py_None;
     1148    alcobject *config;
     1149
     1150    if (!PyArg_ParseTuple(args, "O!:SetConfig", &Alctype, &config))
     1151        return NULL;
     1152    if (ALsetconfig(self->port, config->config) == -1)
     1153        return NULL;
     1154    Py_INCREF(Py_None);
     1155    return Py_None;
    11561156}
    11571157
    … …  
    11591159alp_getconfig(alpobject *self, PyObject *args)
    11601160{
    1161         ALconfig config;
    1162 
    1163         if (!PyArg_ParseTuple(args, ":GetConfig"))
    1164                 return NULL;
    1165         config = ALgetconfig(self->port);
    1166         if (config == NULL)
    1167                 return NULL;
    1168         return newalcobject(config);
     1161    ALconfig config;
     1162
     1163    if (!PyArg_ParseTuple(args, ":GetConfig"))
     1164        return NULL;
     1165    config = ALgetconfig(self->port);
     1166    if (config == NULL)
     1167        return NULL;
     1168    return newalcobject(config);
    11691169}
    11701170
    … …  
    11731173alp_getstatus(alpobject *self, PyObject *args)
    11741174{
    1175         PyObject *list, *v;
    1176         long *PVbuffer;
    1177         long length;
    1178         int i;
    1179        
    1180         if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
    1181                 return NULL;
    1182         length = PyList_Size(list);
    1183         PVbuffer = PyMem_NEW(long, length);
    1184         if (PVbuffer == NULL)
    1185                 return PyErr_NoMemory();
    1186         for (i = 0; i < length; i++) {
    1187                 v = PyList_GetItem(list, i);
    1188                 if (!PyInt_Check(v)) {
    1189                         PyMem_DEL(PVbuffer);
    1190                         PyErr_BadArgument();
    1191                         return NULL;
    1192                 }
    1193                 PVbuffer[i] = PyInt_AsLong(v);
    1194         }
    1195 
    1196         if (ALgetstatus(self->port, PVbuffer, length) == -1)
    1197                 return NULL;
    1198 
    1199         for (i = 0; i < length; i++)
    1200                 PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
    1201 
    1202         PyMem_DEL(PVbuffer);
    1203 
    1204         Py_INCREF(Py_None);
    1205         return Py_None;
     1175    PyObject *list, *v;
     1176    long *PVbuffer;
     1177    long length;
     1178    int i;
     1179
     1180    if (!PyArg_ParseTuple(args, "O!", &PyList_Type, &list))
     1181        return NULL;
     1182    length = PyList_Size(list);
     1183    PVbuffer = PyMem_NEW(long, length);
     1184    if (PVbuffer == NULL)
     1185        return PyErr_NoMemory();
     1186    for (i = 0; i < length; i++) {
     1187        v = PyList_GetItem(list, i);
     1188        if (!PyInt_Check(v)) {
     1189            PyMem_DEL(PVbuffer);
     1190            PyErr_BadArgument();
     1191            return NULL;
     1192        }
     1193        PVbuffer[i] = PyInt_AsLong(v);
     1194    }
     1195
     1196    if (ALgetstatus(self->port, PVbuffer, length) == -1)
     1197        return NULL;
     1198
     1199    for (i = 0; i < length; i++)
     1200        PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
     1201
     1202    PyMem_DEL(PVbuffer);
     1203
     1204    Py_INCREF(Py_None);
     1205    return Py_None;
    12061206}
    12071207#endif /* AL_405 */
    … …  
    12101210
    12111211static struct PyMethodDef alp_methods[] = {
    1212 #ifdef AL_NO_ELEM               /* IRIX 6 */
    1213         {"SetConfig",   (PyCFunction)alp_SetConfig,     METH_VARARGS,   alp_SetConfig__doc__},
    1214         {"GetConfig",   (PyCFunction)alp_GetConfig,     METH_VARARGS,   alp_GetConfig__doc__},
    1215         {"GetResource", (PyCFunction)alp_GetResource,   METH_VARARGS,   alp_GetResource__doc__},
    1216         {"GetFD",       (PyCFunction)alp_GetFD, METH_VARARGS,   alp_GetFD__doc__},
    1217         {"GetFilled",   (PyCFunction)alp_GetFilled,     METH_VARARGS,   alp_GetFilled__doc__},
    1218         {"GetFillable", (PyCFunction)alp_GetFillable,   METH_VARARGS,   alp_GetFillable__doc__},
    1219         {"ReadFrames",  (PyCFunction)alp_ReadFrames,    METH_VARARGS,   alp_ReadFrames__doc__},
    1220         {"DiscardFrames",       (PyCFunction)alp_DiscardFrames, METH_VARARGS,   alp_DiscardFrames__doc__},
    1221         {"ZeroFrames",  (PyCFunction)alp_ZeroFrames,    METH_VARARGS,   alp_ZeroFrames__doc__},
    1222         {"SetFillPoint",        (PyCFunction)alp_SetFillPoint,  METH_VARARGS,   alp_SetFillPoint__doc__},
    1223         {"GetFillPoint",        (PyCFunction)alp_GetFillPoint,  METH_VARARGS,   alp_GetFillPoint__doc__},
    1224         {"GetFrameNumber",      (PyCFunction)alp_GetFrameNumber,        METH_VARARGS,   alp_GetFrameNumber__doc__},
    1225         {"GetFrameTime",        (PyCFunction)alp_GetFrameTime,  METH_VARARGS,   alp_GetFrameTime__doc__},
    1226         {"WriteFrames", (PyCFunction)alp_WriteFrames,   METH_VARARGS,   alp_WriteFrames__doc__},
    1227         {"ClosePort",   (PyCFunction)alp_ClosePort,     METH_VARARGS,   alp_ClosePort__doc__},
     1212#ifdef AL_NO_ELEM               /* IRIX 6 */
     1213    {"SetConfig",       (PyCFunction)alp_SetConfig,     METH_VARARGS,   alp_SetConfig__doc__},
     1214    {"GetConfig",       (PyCFunction)alp_GetConfig,     METH_VARARGS,   alp_GetConfig__doc__},
     1215    {"GetResource",     (PyCFunction)alp_GetResource,   METH_VARARGS,   alp_GetResource__doc__},
     1216    {"GetFD",           (PyCFunction)alp_GetFD, METH_VARARGS,   alp_GetFD__doc__},
     1217    {"GetFilled",       (PyCFunction)alp_GetFilled,     METH_VARARGS,   alp_GetFilled__doc__},
     1218    {"GetFillable",     (PyCFunction)alp_GetFillable,   METH_VARARGS,   alp_GetFillable__doc__},
     1219    {"ReadFrames",      (PyCFunction)alp_ReadFrames,    METH_VARARGS,   alp_ReadFrames__doc__},
     1220    {"DiscardFrames",           (PyCFunction)alp_DiscardFrames, METH_VARARGS,   alp_DiscardFrames__doc__},
     1221    {"ZeroFrames",      (PyCFunction)alp_ZeroFrames,    METH_VARARGS,   alp_ZeroFrames__doc__},
     1222    {"SetFillPoint",            (PyCFunction)alp_SetFillPoint,  METH_VARARGS,   alp_SetFillPoint__doc__},
     1223    {"GetFillPoint",            (PyCFunction)alp_GetFillPoint,  METH_VARARGS,   alp_GetFillPoint__doc__},
     1224    {"GetFrameNumber",          (PyCFunction)alp_GetFrameNumber,        METH_VARARGS,   alp_GetFrameNumber__doc__},
     1225    {"GetFrameTime",            (PyCFunction)alp_GetFrameTime,  METH_VARARGS,   alp_GetFrameTime__doc__},
     1226    {"WriteFrames",     (PyCFunction)alp_WriteFrames,   METH_VARARGS,   alp_WriteFrames__doc__},
     1227    {"ClosePort",       (PyCFunction)alp_ClosePort,     METH_VARARGS,   alp_ClosePort__doc__},
    12281228#endif /* AL_NO_ELEM */
    12291229#ifdef OLD_INTERFACE
    1230         {"closeport",           (PyCFunction)alp_closeport,     METH_VARARGS},
    1231         {"getfd",               (PyCFunction)alp_getfd, METH_VARARGS},
    1232         {"fileno",              (PyCFunction)alp_getfd, METH_VARARGS},
    1233         {"getfilled",           (PyCFunction)alp_getfilled,     METH_VARARGS},
    1234         {"getfillable",         (PyCFunction)alp_getfillable,   METH_VARARGS},
    1235         {"readsamps",           (PyCFunction)alp_readsamps,     METH_VARARGS},
    1236         {"writesamps",          (PyCFunction)alp_writesamps,    METH_VARARGS},
    1237         {"setfillpoint",        (PyCFunction)alp_setfillpoint,  METH_VARARGS},
    1238         {"getfillpoint",        (PyCFunction)alp_getfillpoint,  METH_VARARGS},
    1239         {"setconfig",           (PyCFunction)alp_setconfig,     METH_VARARGS},
    1240         {"getconfig",           (PyCFunction)alp_getconfig,     METH_VARARGS},
     1230    {"closeport",               (PyCFunction)alp_closeport,     METH_VARARGS},
     1231    {"getfd",                   (PyCFunction)alp_getfd, METH_VARARGS},
     1232    {"fileno",                  (PyCFunction)alp_getfd, METH_VARARGS},
     1233    {"getfilled",               (PyCFunction)alp_getfilled,     METH_VARARGS},
     1234    {"getfillable",             (PyCFunction)alp_getfillable,   METH_VARARGS},
     1235    {"readsamps",               (PyCFunction)alp_readsamps,     METH_VARARGS},
     1236    {"writesamps",              (PyCFunction)alp_writesamps,    METH_VARARGS},
     1237    {"setfillpoint",            (PyCFunction)alp_setfillpoint,  METH_VARARGS},
     1238    {"getfillpoint",            (PyCFunction)alp_getfillpoint,  METH_VARARGS},
     1239    {"setconfig",               (PyCFunction)alp_setconfig,     METH_VARARGS},
     1240    {"getconfig",               (PyCFunction)alp_getconfig,     METH_VARARGS},
    12411241#ifdef AL_405
    1242         {"getstatus",           (PyCFunction)alp_getstatus,     METH_VARARGS},
    1243 #endif /* AL_405 */         
     1242    {"getstatus",               (PyCFunction)alp_getstatus,     METH_VARARGS},
     1243#endif /* AL_405 */
    12441244#endif /* OLD_INTERFACE */
    1245  
    1246         {NULL,          NULL}           /* sentinel */
     1245
     1246    {NULL,              NULL}           /* sentinel */
    12471247};
    12481248
    … …  
    12531253newalpobject(ALport port)
    12541254{
    1255         alpobject *self;
    1256        
    1257         self = PyObject_New(alpobject, &Alptype);
    1258         if (self == NULL)
    1259                 return NULL;
    1260         /* XXXX Add your own initializers here */
    1261         self->port = port;
    1262         return (PyObject *) self;
     1255    alpobject *self;
     1256
     1257    self = PyObject_New(alpobject, &Alptype);
     1258    if (self == NULL)
     1259        return NULL;
     1260    /* XXXX Add your own initializers here */
     1261    self->port = port;
     1262    return (PyObject *) self;
    12631263}
    12641264
    … …  
    12671267alp_dealloc(alpobject *self)
    12681268{
    1269         /* XXXX Add your own cleanup code here */
    1270         if (self->port) {
    1271 #ifdef AL_NO_ELEM               /* IRIX 6 */
    1272                 alClosePort(self->port);
     1269    /* XXXX Add your own cleanup code here */
     1270    if (self->port) {
     1271#ifdef AL_NO_ELEM               /* IRIX 6 */
     1272        alClosePort(self->port);
    12731273#else
    1274                 ALcloseport(self->port);
    1275 #endif
    1276         }
    1277         PyObject_Del(self);
     1274        ALcloseport(self->port);
     1275#endif
     1276    }
     1277    PyObject_Del(self);
    12781278}
    12791279
    … …  
    12811281alp_getattr(alpobject *self, char *name)
    12821282{
    1283         /* XXXX Add your own getattr code here */
    1284         if (self->port == NULL) {
    1285                 PyErr_SetString(ErrorObject, "port already closed");
    1286                 return NULL;
    1287         }
    1288         return Py_FindMethod(alp_methods, (PyObject *)self, name);
     1283    /* XXXX Add your own getattr code here */
     1284    if (self->port == NULL) {
     1285        PyErr_SetString(ErrorObject, "port already closed");
     1286        return NULL;
     1287    }
     1288    return Py_FindMethod(alp_methods, (PyObject *)self, name);
    12891289}
    12901290
    … …  
    12921292
    12931293static PyTypeObject Alptype = {
    1294         PyObject_HEAD_INIT(&PyType_Type)
    1295         0,                              /*ob_size*/
    1296         "al.port",                      /*tp_name*/
    1297         sizeof(alpobject),              /*tp_basicsize*/
    1298         0,                              /*tp_itemsize*/
    1299         /* methods */
    1300         (destructor)alp_dealloc,        /*tp_dealloc*/
    1301         (printfunc)0,           /*tp_print*/
    1302         (getattrfunc)alp_getattr,       /*tp_getattr*/
    1303         (setattrfunc)0, /*tp_setattr*/
    1304         (cmpfunc)0,             /*tp_compare*/
    1305         (reprfunc)0,            /*tp_repr*/
    1306         0,                      /*tp_as_number*/
    1307         0,              /*tp_as_sequence*/
    1308         0,              /*tp_as_mapping*/
    1309         (hashfunc)0,            /*tp_hash*/
    1310         (ternaryfunc)0,         /*tp_call*/
    1311         (reprfunc)0,            /*tp_str*/
    1312 
    1313         /* Space for future expansion */
    1314         0L,0L,0L,0L,
    1315         Alptype__doc__ /* Documentation string */
     1294    PyObject_HEAD_INIT(&PyType_Type)
     1295    0,                                  /*ob_size*/
     1296    "al.port",                          /*tp_name*/
     1297    sizeof(alpobject),                  /*tp_basicsize*/
     1298    0,                                  /*tp_itemsize*/
     1299    /* methods */
     1300    (destructor)alp_dealloc,            /*tp_dealloc*/
     1301    (printfunc)0,               /*tp_print*/
     1302    (getattrfunc)alp_getattr,           /*tp_getattr*/
     1303    (setattrfunc)0,     /*tp_setattr*/
     1304    (cmpfunc)0,                 /*tp_compare*/
     1305    (reprfunc)0,                /*tp_repr*/
     1306    0,                          /*tp_as_number*/
     1307    0,                  /*tp_as_sequence*/
     1308    0,                  /*tp_as_mapping*/
     1309    (hashfunc)0,                /*tp_hash*/
     1310    (ternaryfunc)0,             /*tp_call*/
     1311    (reprfunc)0,                /*tp_str*/
     1312
     1313    /* Space for future expansion */
     1314    0L,0L,0L,0L,
     1315    Alptype__doc__ /* Documentation string */
    13161316};
    13171317
    … …  
    13201320
    13211321
    1322 #ifdef AL_NO_ELEM               /* IRIX 6 */
     1322#ifdef AL_NO_ELEM               /* IRIX 6 */
    13231323
    13241324PyDoc_STRVAR(al_NewConfig__doc__,
    … …  
    13281328al_NewConfig(PyObject *self, PyObject *args)
    13291329{
    1330         ALconfig config;
    1331 
    1332         if (!PyArg_ParseTuple(args, ":NewConfig"))
    1333                 return NULL;
    1334         if ((config = alNewConfig()) == NULL)
    1335                 return NULL;
    1336         return newalcobject(config);
     1330    ALconfig config;
     1331
     1332    if (!PyArg_ParseTuple(args, ":NewConfig"))
     1333        return NULL;
     1334    if ((config = alNewConfig()) == NULL)
     1335        return NULL;
     1336    return newalcobject(config);
    13371337}
    13381338
    … …  
    13431343al_OpenPort(PyObject *self, PyObject *args)
    13441344{
    1345         ALport port;
    1346         char *name, *dir;
    1347         alcobject *config = NULL;
    1348 
    1349         if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
    1350                 return NULL;
    1351         if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
    1352                 return NULL;
    1353         return newalpobject(port);
     1345    ALport port;
     1346    char *name, *dir;
     1347    alcobject *config = NULL;
     1348
     1349    if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
     1350        return NULL;
     1351    if ((port = alOpenPort(name, dir, config ? config->config : NULL)) == NULL)
     1352        return NULL;
     1353    return newalpobject(port);
    13541354}
    13551355
    … …  
    13601360al_Connect(PyObject *self, PyObject *args)
    13611361{
    1362         int source, dest, nprops = 0, id, i;
    1363         ALpv *props = NULL;
    1364         ALparamInfo *propinfo = NULL;
    1365         PyObject *propobj = NULL;
    1366 
    1367         if (!PyArg_ParseTuple(args, "ii|O!:Connect", &source, &dest, &PyList_Type, &propobj))
    1368                 return NULL;
    1369         if (propobj != NULL) {
    1370                 nprops = python2params(source, dest, propobj, &props, &propinfo);
    1371                 if (nprops < 0)
    1372                         return NULL;
    1373         }
    1374 
    1375         id = alConnect(source, dest, props, nprops);
    1376 
    1377         if (props) {
    1378                 for (i = 0; i < nprops; i++) {
    1379                         switch (propinfo[i].valueType) {
    1380                         case AL_SET_VAL:
    1381                         case AL_VECTOR_VAL:
    1382                                 PyMem_DEL(props[i].value.ptr);
    1383                                 break;
    1384                         }
    1385                 }
    1386                 PyMem_DEL(props);
    1387                 PyMem_DEL(propinfo);
    1388         }
    1389 
    1390         if (id < 0)
    1391                 return NULL;
    1392         return PyInt_FromLong((long) id);
     1362    int source, dest, nprops = 0, id, i;
     1363    ALpv *props = NULL;
     1364    ALparamInfo *propinfo = NULL;
     1365    PyObject *propobj = NULL;
     1366
     1367    if (!PyArg_ParseTuple(args, "ii|O!:Connect", &source, &dest, &PyList_Type, &propobj))
     1368        return NULL;
     1369    if (propobj != NULL) {
     1370        nprops = python2params(source, dest, propobj, &props, &propinfo);
     1371        if (nprops < 0)
     1372            return NULL;
     1373    }
     1374
     1375    id = alConnect(source, dest, props, nprops);
     1376
     1377    if (props) {
     1378        for (i = 0; i < nprops; i++) {
     1379            switch (propinfo[i].valueType) {
     1380            case AL_SET_VAL:
     1381            case AL_VECTOR_VAL:
     1382                PyMem_DEL(props[i].value.ptr);
     1383                break;
     1384            }
     1385        }
     1386        PyMem_DEL(props);
     1387        PyMem_DEL(propinfo);
     1388    }
     1389
     1390    if (id < 0)
     1391        return NULL;
     1392    return PyInt_FromLong((long) id);
    13931393}
    13941394
    … …  
    13991399al_Disconnect(PyObject *self, PyObject *args)
    14001400{
    1401         int res;
    1402 
    1403         if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
    1404                 return NULL;
    1405         if (alDisconnect(res) < 0)
    1406                 return NULL;
    1407         Py_INCREF(Py_None);
    1408         return Py_None;
     1401    int res;
     1402
     1403    if (!PyArg_ParseTuple(args, "i:Disconnect", &res))
     1404        return NULL;
     1405    if (alDisconnect(res) < 0)
     1406        return NULL;
     1407    Py_INCREF(Py_None);
     1408    return Py_None;
    14091409}
    14101410
    … …  
    14151415al_GetParams(PyObject *self, PyObject *args)
    14161416{
    1417         int resource;
    1418         PyObject *pvslist, *item = NULL, *v = NULL;
    1419         ALpv *pvs;
    1420         int i, j, npvs;
    1421         ALparamInfo *pinfo;
    1422 
    1423         if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
    1424                 return NULL;
    1425         npvs = PyList_Size(pvslist);
    1426         pvs = PyMem_NEW(ALpv, npvs);
    1427         pinfo = PyMem_NEW(ALparamInfo, npvs);
    1428         for (i = 0; i < npvs; i++) {
    1429                 item = PyList_GetItem(pvslist, i);
    1430                 if (!PyInt_Check(item)) {
    1431                         item = NULL;
    1432                         PyErr_SetString(ErrorObject, "list of integers expected");
    1433                         goto error;
    1434                 }
    1435                 pvs[i].param = (int) PyInt_AsLong(item);
    1436                 item = NULL;    /* not needed anymore */
    1437                 if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
    1438                         goto error;
    1439                 switch (pinfo[i].valueType) {
    1440                 case AL_NO_VAL:
    1441                         break;
    1442                 case AL_MATRIX_VAL:
    1443                         pinfo[i].maxElems *= pinfo[i].maxElems2;
    1444                         /* fall through */
    1445                 case AL_STRING_VAL:
    1446                 case AL_SET_VAL:
    1447                 case AL_VECTOR_VAL:
    1448                         switch (pinfo[i].elementType) {
    1449                         case AL_INT32_ELEM:
    1450                         case AL_RESOURCE_ELEM:
    1451                         case AL_ENUM_ELEM:
    1452                                 pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
    1453                                 pvs[i].sizeIn = pinfo[i].maxElems;
    1454                                 break;
    1455                         case AL_INT64_ELEM:
    1456                         case AL_FIXED_ELEM:
    1457                                 pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
    1458                                 pvs[i].sizeIn = pinfo[i].maxElems;
    1459                                 break;
    1460                         case AL_CHAR_ELEM:
    1461                                 pvs[i].value.ptr = PyMem_NEW(char, 32);
    1462                                 pvs[i].sizeIn = 32;
    1463                                 break;
    1464                         case AL_NO_ELEM:
    1465                         case AL_PTR_ELEM:
    1466                         default:
    1467                                 PyErr_SetString(ErrorObject, "internal error");
    1468                                 goto error;
    1469                         }
    1470                         break;
    1471                 case AL_SCALAR_VAL:
    1472                         break;
    1473                 default:
    1474                         PyErr_SetString(ErrorObject, "internal error");
    1475                         goto error;
    1476                 }
    1477                 if (pinfo[i].valueType == AL_MATRIX_VAL) {
    1478                         pinfo[i].maxElems /= pinfo[i].maxElems2;
    1479                         pvs[i].sizeIn /= pinfo[i].maxElems2;
    1480                         pvs[i].size2In = pinfo[i].maxElems2;
    1481                 }
    1482         }
    1483         if (alGetParams(resource, pvs, npvs) < 0)
    1484                 goto error;
    1485         if (!(v = PyList_New(npvs)))
    1486                 goto error;
    1487         for (i = 0; i < npvs; i++) {
    1488                 if (pvs[i].sizeOut < 0) {
    1489                         char buf[32];
    1490                         PyOS_snprintf(buf, sizeof(buf),
    1491                                       "problem with param %d", i);
    1492                         PyErr_SetString(ErrorObject, buf);
    1493                         goto error;
    1494                 }
    1495                 switch (pinfo[i].valueType) {
    1496                 case AL_NO_VAL:
    1497                         item = Py_None;
    1498                         Py_INCREF(item);
    1499                         break;
    1500                 case AL_STRING_VAL:
    1501                         item = PyString_FromString(pvs[i].value.ptr);
    1502                         PyMem_DEL(pvs[i].value.ptr);
    1503                         break;
    1504                 case AL_MATRIX_VAL:
    1505                         /* XXXX this is not right */
    1506                         pvs[i].sizeOut *= pvs[i].size2Out;
    1507                         /* fall through */
    1508                 case AL_SET_VAL:
    1509                 case AL_VECTOR_VAL:
    1510                         item = PyList_New(pvs[i].sizeOut);
    1511                         for (j = 0; j < pvs[i].sizeOut; j++) {
    1512                                 switch (pinfo[i].elementType) {
    1513                                 case AL_INT32_ELEM:
    1514                                 case AL_RESOURCE_ELEM:
    1515                                 case AL_ENUM_ELEM:
    1516                                         PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
    1517                                         break;
    1518                                 case AL_INT64_ELEM:
    1519                                         PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
    1520                                         break;
    1521                                 case AL_FIXED_ELEM:
    1522                                         PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
    1523                                         break;
    1524                                 default:
    1525                                         PyErr_SetString(ErrorObject, "internal error");
    1526                                         goto error;
    1527                                 }
    1528                         }
    1529                         PyMem_DEL(pvs[i].value.ptr);
    1530                         break;
    1531                 case AL_SCALAR_VAL:
    1532                         item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
    1533                         break;
    1534                 }
    1535                 if (PyErr_Occurred() ||
    1536                     PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
    1537                                                        item)) < 0 ||
    1538                     PyErr_Occurred())
    1539                         goto error;
    1540                 Py_DECREF(item);
    1541         }
    1542         PyMem_DEL(pvs);
    1543         PyMem_DEL(pinfo);
    1544         return v;
     1417    int resource;
     1418    PyObject *pvslist, *item = NULL, *v = NULL;
     1419    ALpv *pvs;
     1420    int i, j, npvs;
     1421    ALparamInfo *pinfo;
     1422
     1423    if (!PyArg_ParseTuple(args, "iO!:GetParams", &resource, &PyList_Type, &pvslist))
     1424        return NULL;
     1425    npvs = PyList_Size(pvslist);
     1426    pvs = PyMem_NEW(ALpv, npvs);
     1427    pinfo = PyMem_NEW(ALparamInfo, npvs);
     1428    for (i = 0; i < npvs; i++) {
     1429        item = PyList_GetItem(pvslist, i);
     1430        if (!PyInt_Check(item)) {
     1431            item = NULL;
     1432            PyErr_SetString(ErrorObject, "list of integers expected");
     1433            goto error;
     1434        }
     1435        pvs[i].param = (int) PyInt_AsLong(item);
     1436        item = NULL;            /* not needed anymore */
     1437        if (alGetParamInfo(resource, pvs[i].param, &pinfo[i]) < 0)
     1438            goto error;
     1439        switch (pinfo[i].valueType) {
     1440        case AL_NO_VAL:
     1441            break;
     1442        case AL_MATRIX_VAL:
     1443            pinfo[i].maxElems *= pinfo[i].maxElems2;
     1444            /* fall through */
     1445        case AL_STRING_VAL:
     1446        case AL_SET_VAL:
     1447        case AL_VECTOR_VAL:
     1448            switch (pinfo[i].elementType) {
     1449            case AL_INT32_ELEM:
     1450            case AL_RESOURCE_ELEM:
     1451            case AL_ENUM_ELEM:
     1452                pvs[i].value.ptr = PyMem_NEW(int, pinfo[i].maxElems);
     1453                pvs[i].sizeIn = pinfo[i].maxElems;
     1454                break;
     1455            case AL_INT64_ELEM:
     1456            case AL_FIXED_ELEM:
     1457                pvs[i].value.ptr = PyMem_NEW(long long, pinfo[i].maxElems);
     1458                pvs[i].sizeIn = pinfo[i].maxElems;
     1459                break;
     1460            case AL_CHAR_ELEM:
     1461                pvs[i].value.ptr = PyMem_NEW(char, 32);
     1462                pvs[i].sizeIn = 32;
     1463                break;
     1464            case AL_NO_ELEM:
     1465            case AL_PTR_ELEM:
     1466            default:
     1467                PyErr_SetString(ErrorObject, "internal error");
     1468                goto error;
     1469            }
     1470            break;
     1471        case AL_SCALAR_VAL:
     1472            break;
     1473        default:
     1474            PyErr_SetString(ErrorObject, "internal error");
     1475            goto error;
     1476        }
     1477        if (pinfo[i].valueType == AL_MATRIX_VAL) {
     1478            pinfo[i].maxElems /= pinfo[i].maxElems2;
     1479            pvs[i].sizeIn /= pinfo[i].maxElems2;
     1480            pvs[i].size2In = pinfo[i].maxElems2;
     1481        }
     1482    }
     1483    if (alGetParams(resource, pvs, npvs) < 0)
     1484        goto error;
     1485    if (!(v = PyList_New(npvs)))
     1486        goto error;
     1487    for (i = 0; i < npvs; i++) {
     1488        if (pvs[i].sizeOut < 0) {
     1489            char buf[32];
     1490            PyOS_snprintf(buf, sizeof(buf),
     1491                          "problem with param %d", i);
     1492            PyErr_SetString(ErrorObject, buf);
     1493            goto error;
     1494        }
     1495        switch (pinfo[i].valueType) {
     1496        case AL_NO_VAL:
     1497            item = Py_None;
     1498            Py_INCREF(item);
     1499            break;
     1500        case AL_STRING_VAL:
     1501            item = PyString_FromString(pvs[i].value.ptr);
     1502            PyMem_DEL(pvs[i].value.ptr);
     1503            break;
     1504        case AL_MATRIX_VAL:
     1505            /* XXXX this is not right */
     1506            pvs[i].sizeOut *= pvs[i].size2Out;
     1507            /* fall through */
     1508        case AL_SET_VAL:
     1509        case AL_VECTOR_VAL:
     1510            item = PyList_New(pvs[i].sizeOut);
     1511            for (j = 0; j < pvs[i].sizeOut; j++) {
     1512                switch (pinfo[i].elementType) {
     1513                case AL_INT32_ELEM:
     1514                case AL_RESOURCE_ELEM:
     1515                case AL_ENUM_ELEM:
     1516                    PyList_SetItem(item, j, PyInt_FromLong((long) ((int *) pvs[i].value.ptr)[j]));
     1517                    break;
     1518                case AL_INT64_ELEM:
     1519                    PyList_SetItem(item, j, PyLong_FromLongLong(((long long *) pvs[i].value.ptr)[j]));
     1520                    break;
     1521                case AL_FIXED_ELEM:
     1522                    PyList_SetItem(item, j, PyFloat_FromDouble(alFixedToDouble(((long long *) pvs[i].value.ptr)[j])));
     1523                    break;
     1524                default:
     1525                    PyErr_SetString(ErrorObject, "internal error");
     1526                    goto error;
     1527                }
     1528            }
     1529            PyMem_DEL(pvs[i].value.ptr);
     1530            break;
     1531        case AL_SCALAR_VAL:
     1532            item = param2python(resource, pvs[i].param, pvs[i].value, &pinfo[i]);
     1533            break;
     1534        }
     1535        if (PyErr_Occurred() ||
     1536            PyList_SetItem(v, i, Py_BuildValue("(iO)", pvs[i].param,
     1537                                               item)) < 0 ||
     1538            PyErr_Occurred())
     1539            goto error;
     1540        Py_DECREF(item);
     1541    }
     1542    PyMem_DEL(pvs);
     1543    PyMem_DEL(pinfo);
     1544    return v;
    15451545
    15461546  error:
    1547         Py_XDECREF(v);
    1548         Py_XDECREF(item);
    1549         if (pvs)
    1550                 PyMem_DEL(pvs);
    1551         if (pinfo)
    1552                 PyMem_DEL(pinfo);
    1553         return NULL;
     1547    Py_XDECREF(v);
     1548    Py_XDECREF(item);
     1549    if (pvs)
     1550        PyMem_DEL(pvs);
     1551    if (pinfo)
     1552        PyMem_DEL(pinfo);
     1553    return NULL;
    15541554}
    15551555
    … …  
    15601560al_SetParams(PyObject *self, PyObject *args)
    15611561{
    1562         int resource;
    1563         PyObject *pvslist;
    1564         ALpv *pvs;
    1565         ALparamInfo *pinfo;
    1566         int npvs, i;
    1567 
    1568         if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
    1569                 return NULL;
    1570         npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
    1571         if (npvs < 0)
    1572                 return NULL;
    1573 
    1574         if (alSetParams(resource, pvs, npvs) < 0)
    1575                 goto error;
    1576 
    1577         /* cleanup */
    1578         for (i = 0; i < npvs; i++) {
    1579                 switch (pinfo[i].valueType) {
    1580                 case AL_SET_VAL:
    1581                 case AL_VECTOR_VAL:
    1582                         PyMem_DEL(pvs[i].value.ptr);
    1583                         break;
    1584                 }
    1585         }
    1586         PyMem_DEL(pvs);
    1587         PyMem_DEL(pinfo);
    1588 
    1589         Py_INCREF(Py_None);
    1590         return Py_None;
     1562    int resource;
     1563    PyObject *pvslist;
     1564    ALpv *pvs;
     1565    ALparamInfo *pinfo;
     1566    int npvs, i;
     1567
     1568    if (!PyArg_ParseTuple(args, "iO!:SetParams", &resource, &PyList_Type, &pvslist))
     1569        return NULL;
     1570    npvs = python2params(resource, -1, pvslist, &pvs, &pinfo);
     1571    if (npvs < 0)
     1572        return NULL;
     1573
     1574    if (alSetParams(resource, pvs, npvs) < 0)
     1575        goto error;
     1576
     1577    /* cleanup */
     1578    for (i = 0; i < npvs; i++) {
     1579        switch (pinfo[i].valueType) {
     1580        case AL_SET_VAL:
     1581        case AL_VECTOR_VAL:
     1582            PyMem_DEL(pvs[i].value.ptr);
     1583            break;
     1584        }
     1585    }
     1586    PyMem_DEL(pvs);
     1587    PyMem_DEL(pinfo);
     1588
     1589    Py_INCREF(Py_None);
     1590    return Py_None;
    15911591
    15921592  error:
    1593         /* XXXX we should clean up everything */
    1594         if (pvs)
    1595                 PyMem_DEL(pvs);
    1596         if (pinfo)
    1597                 PyMem_DEL(pinfo);
    1598         return NULL;
     1593    /* XXXX we should clean up everything */
     1594    if (pvs)
     1595        PyMem_DEL(pvs);
     1596    if (pinfo)
     1597        PyMem_DEL(pinfo);
     1598    return NULL;
    15991599}
    16001600
    … …  
    16051605al_QueryValues(PyObject *self, PyObject *args)
    16061606{
    1607         int resource, param;
    1608         ALvalue *return_set = NULL;
    1609         int setsize = 32, qualsize = 0, nvals, i;
    1610         ALpv *quals = NULL;
    1611         ALparamInfo pinfo;
    1612         ALparamInfo *qualinfo = NULL;
    1613         PyObject *qualobj = NULL;
    1614         PyObject *res = NULL, *item;
    1615 
    1616         if (!PyArg_ParseTuple(args, "ii|O!:QueryValues", &resource, &param,
    1617                               &PyList_Type, &qualobj))
    1618                 return NULL;
    1619         if (qualobj != NULL) {
    1620                 qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
    1621                 if (qualsize < 0)
    1622                         return NULL;
    1623         }
    1624         setsize = 32;
    1625         return_set = PyMem_NEW(ALvalue, setsize);
    1626         if (return_set == NULL) {
    1627                 PyErr_NoMemory();
    1628                 goto cleanup;
    1629         }
     1607    int resource, param;
     1608    ALvalue *return_set = NULL;
     1609    int setsize = 32, qualsize = 0, nvals, i;
     1610    ALpv *quals = NULL;
     1611    ALparamInfo pinfo;
     1612    ALparamInfo *qualinfo = NULL;
     1613    PyObject *qualobj = NULL;
     1614    PyObject *res = NULL, *item;
     1615
     1616    if (!PyArg_ParseTuple(args, "ii|O!:QueryValues", &resource, &param,
     1617                          &PyList_Type, &qualobj))
     1618        return NULL;
     1619    if (qualobj != NULL) {
     1620        qualsize = python2params(resource, param, qualobj, &quals, &qualinfo);
     1621        if (qualsize < 0)
     1622            return NULL;
     1623    }
     1624    setsize = 32;
     1625    return_set = PyMem_NEW(ALvalue, setsize);
     1626    if (return_set == NULL) {
     1627        PyErr_NoMemory();
     1628        goto cleanup;
     1629    }
    16301630
    16311631  retry:
    1632         nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
    1633         if (nvals < 0)
    1634                 goto cleanup;
    1635         if (nvals > setsize) {
    1636                 ALvalue *old_return_set = return_set;
    1637                 setsize = nvals;
    1638                 PyMem_RESIZE(return_set, ALvalue, setsize);
    1639                 if (return_set == NULL) {
    1640                         return_set = old_return_set;
    1641                         PyErr_NoMemory();
    1642                         goto cleanup;
    1643                 }
    1644                 goto retry;
    1645         }
    1646 
    1647         if (alGetParamInfo(resource, param, &pinfo) < 0)
    1648                 goto cleanup;
    1649 
    1650         res = PyList_New(nvals);
    1651         if (res == NULL)
    1652                 goto cleanup;
    1653         for (i = 0; i < nvals; i++) {
    1654                 item = param2python(resource, param, return_set[i], &pinfo);
    1655                 if (item == NULL ||
    1656                     PyList_SetItem(res, i, item) < 0) {
    1657                         Py_DECREF(res);
    1658                         res = NULL;
    1659                         goto cleanup;
    1660                 }
    1661         }
     1632    nvals = alQueryValues(resource, param, return_set, setsize, quals, qualsize);
     1633    if (nvals < 0)
     1634        goto cleanup;
     1635    if (nvals > setsize) {
     1636        ALvalue *old_return_set = return_set;
     1637        setsize = nvals;
     1638        PyMem_RESIZE(return_set, ALvalue, setsize);
     1639        if (return_set == NULL) {
     1640            return_set = old_return_set;
     1641            PyErr_NoMemory();
     1642            goto cleanup;
     1643        }
     1644        goto retry;
     1645    }
     1646
     1647    if (alGetParamInfo(resource, param, &pinfo) < 0)
     1648        goto cleanup;
     1649
     1650    res = PyList_New(nvals);
     1651    if (res == NULL)
     1652        goto cleanup;
     1653    for (i = 0; i < nvals; i++) {
     1654        item = param2python(resource, param, return_set[i], &pinfo);
     1655        if (item == NULL ||
     1656            PyList_SetItem(res, i, item) < 0) {
     1657            Py_DECREF(res);
     1658            res = NULL;
     1659            goto cleanup;
     1660        }
     1661    }
    16621662
    16631663  cleanup:
    1664         if (return_set)
    1665                 PyMem_DEL(return_set);
    1666         if (quals) {
    1667                 for (i = 0; i < qualsize; i++) {
    1668                         switch (qualinfo[i].valueType) {
    1669                         case AL_SET_VAL:
    1670                         case AL_VECTOR_VAL:
    1671                                 PyMem_DEL(quals[i].value.ptr);
    1672                                 break;
    1673                         }
    1674                 }
    1675                 PyMem_DEL(quals);
    1676                 PyMem_DEL(qualinfo);
    1677         }
    1678 
    1679         return res;
     1664    if (return_set)
     1665        PyMem_DEL(return_set);
     1666    if (quals) {
     1667        for (i = 0; i < qualsize; i++) {
     1668            switch (qualinfo[i].valueType) {
     1669            case AL_SET_VAL:
     1670            case AL_VECTOR_VAL:
     1671                PyMem_DEL(quals[i].value.ptr);
     1672                break;
     1673            }
     1674        }
     1675        PyMem_DEL(quals);
     1676        PyMem_DEL(qualinfo);
     1677    }
     1678
     1679    return res;
    16801680}
    16811681
    … …  
    16871687al_GetParamInfo(PyObject *self, PyObject *args)
    16881688{
    1689         int res, param;
    1690         ALparamInfo pinfo;
    1691         PyObject *v, *item;
    1692 
    1693         if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
    1694                 return NULL;
    1695         if (alGetParamInfo(res, param, &pinfo) < 0)
    1696                 return NULL;
    1697         v = PyDict_New();
    1698         if (!v) return NULL;
    1699 
    1700         item = PyInt_FromLong((long) pinfo.resource);
    1701         PyDict_SetItemString(v, "resource", item);
    1702         Py_DECREF(item);
    1703 
    1704         item = PyInt_FromLong((long) pinfo.param);
    1705         PyDict_SetItemString(v, "param", item);
    1706         Py_DECREF(item);
    1707 
    1708         item = PyInt_FromLong((long) pinfo.valueType);
    1709         PyDict_SetItemString(v, "valueType", item);
    1710         Py_DECREF(item);
    1711 
    1712         if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
    1713                 /* multiple values */
    1714                 item = PyInt_FromLong((long) pinfo.maxElems);
    1715                 PyDict_SetItemString(v, "maxElems", item);
    1716                 Py_DECREF(item);
    1717 
    1718                 if (pinfo.valueType == AL_MATRIX_VAL) {
    1719                         /* 2 dimensional */
    1720                         item = PyInt_FromLong((long) pinfo.maxElems2);
    1721                         PyDict_SetItemString(v, "maxElems2", item);
    1722                         Py_DECREF(item);
    1723                 }
    1724         }
    1725 
    1726         item = PyInt_FromLong((long) pinfo.elementType);
    1727         PyDict_SetItemString(v, "elementType", item);
    1728         Py_DECREF(item);
    1729 
    1730         item = PyString_FromString(pinfo.name);
    1731         PyDict_SetItemString(v, "name", item);
    1732         Py_DECREF(item);
    1733 
    1734         item = param2python(res, param, pinfo.initial, &pinfo);
    1735         PyDict_SetItemString(v, "initial", item);
    1736         Py_DECREF(item);
    1737 
    1738         if (pinfo.elementType != AL_ENUM_ELEM &&
    1739             pinfo.elementType != AL_RESOURCE_ELEM &&
    1740             pinfo.elementType != AL_CHAR_ELEM) {
    1741                 /* range param */
    1742                 item = param2python(res, param, pinfo.min, &pinfo);
    1743                 PyDict_SetItemString(v, "min", item);
    1744                 Py_DECREF(item);
    1745 
    1746                 item = param2python(res, param, pinfo.max, &pinfo);
    1747                 PyDict_SetItemString(v, "max", item);
    1748                 Py_DECREF(item);
    1749 
    1750                 item = param2python(res, param, pinfo.minDelta, &pinfo);
    1751                 PyDict_SetItemString(v, "minDelta", item);
    1752                 Py_DECREF(item);
    1753 
    1754                 item = param2python(res, param, pinfo.maxDelta, &pinfo);
    1755                 PyDict_SetItemString(v, "maxDelta", item);
    1756                 Py_DECREF(item);
    1757 
    1758                 item = PyInt_FromLong((long) pinfo.specialVals);
    1759                 PyDict_SetItemString(v, "specialVals", item);
    1760                 Py_DECREF(item);
    1761         }
    1762 
    1763         return v;
     1689    int res, param;
     1690    ALparamInfo pinfo;
     1691    PyObject *v, *item;
     1692
     1693    if (!PyArg_ParseTuple(args, "ii:GetParamInfo", &res, &param))
     1694        return NULL;
     1695    if (alGetParamInfo(res, param, &pinfo) < 0)
     1696        return NULL;
     1697    v = PyDict_New();
     1698    if (!v) return NULL;
     1699
     1700    item = PyInt_FromLong((long) pinfo.resource);
     1701    PyDict_SetItemString(v, "resource", item);
     1702    Py_DECREF(item);
     1703
     1704    item = PyInt_FromLong((long) pinfo.param);
     1705    PyDict_SetItemString(v, "param", item);
     1706    Py_DECREF(item);
     1707
     1708    item = PyInt_FromLong((long) pinfo.valueType);
     1709    PyDict_SetItemString(v, "valueType", item);
     1710    Py_DECREF(item);
     1711
     1712    if (pinfo.valueType != AL_NO_VAL && pinfo.valueType != AL_SCALAR_VAL) {
     1713        /* multiple values */
     1714        item = PyInt_FromLong((long) pinfo.maxElems);
     1715        PyDict_SetItemString(v, "maxElems", item);
     1716        Py_DECREF(item);
     1717
     1718        if (pinfo.valueType == AL_MATRIX_VAL) {
     1719            /* 2 dimensional */
     1720            item = PyInt_FromLong((long) pinfo.maxElems2);
     1721            PyDict_SetItemString(v, "maxElems2", item);
     1722            Py_DECREF(item);
     1723        }
     1724    }
     1725
     1726    item = PyInt_FromLong((long) pinfo.elementType);
     1727    PyDict_SetItemString(v, "elementType", item);
     1728    Py_DECREF(item);
     1729
     1730    item = PyString_FromString(pinfo.name);
     1731    PyDict_SetItemString(v, "name", item);
     1732    Py_DECREF(item);
     1733
     1734    item = param2python(res, param, pinfo.initial, &pinfo);
     1735    PyDict_SetItemString(v, "initial", item);
     1736    Py_DECREF(item);
     1737
     1738    if (pinfo.elementType != AL_ENUM_ELEM &&
     1739        pinfo.elementType != AL_RESOURCE_ELEM &&
     1740        pinfo.elementType != AL_CHAR_ELEM) {
     1741        /* range param */
     1742        item = param2python(res, param, pinfo.min, &pinfo);
     1743        PyDict_SetItemString(v, "min", item);
     1744        Py_DECREF(item);
     1745
     1746        item = param2python(res, param, pinfo.max, &pinfo);
     1747        PyDict_SetItemString(v, "max", item);
     1748        Py_DECREF(item);
     1749
     1750        item = param2python(res, param, pinfo.minDelta, &pinfo);
     1751        PyDict_SetItemString(v, "minDelta", item);
     1752        Py_DECREF(item);
     1753
     1754        item = param2python(res, param, pinfo.maxDelta, &pinfo);
     1755        PyDict_SetItemString(v, "maxDelta", item);
     1756        Py_DECREF(item);
     1757
     1758        item = PyInt_FromLong((long) pinfo.specialVals);
     1759        PyDict_SetItemString(v, "specialVals", item);
     1760        Py_DECREF(item);
     1761    }
     1762
     1763    return v;
    17641764}
    17651765
    … …  
    17701770al_GetResourceByName(PyObject *self, PyObject *args)
    17711771{
    1772         int res, start_res, type;
    1773         char *name;
    1774 
    1775         if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
    1776                 return NULL;
    1777         if ((res = alGetResourceByName(start_res, name, type)) == 0)
    1778                 return NULL;
    1779         return PyInt_FromLong((long) res);
     1772    int res, start_res, type;
     1773    char *name;
     1774
     1775    if (!PyArg_ParseTuple(args, "isi:GetResourceByName", &start_res, &name, &type))
     1776        return NULL;
     1777    if ((res = alGetResourceByName(start_res, name, type)) == 0)
     1778        return NULL;
     1779    return PyInt_FromLong((long) res);
    17801780}
    17811781
    … …  
    17861786al_IsSubtype(PyObject *self, PyObject *args)
    17871787{
    1788         int type, subtype;
    1789 
    1790         if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
    1791                 return NULL;
    1792         return PyInt_FromLong((long) alIsSubtype(type, subtype));
     1788    int type, subtype;
     1789
     1790    if (!PyArg_ParseTuple(args, "ii:IsSubtype", &type, &subtype))
     1791        return NULL;
     1792    return PyInt_FromLong((long) alIsSubtype(type, subtype));
    17931793}
    17941794
    … …  
    17991799{
    18001800
    1801         if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
    1802                 return NULL;
    1803         Py_INCREF(Py_None);
    1804         return Py_None;
     1801    if (!PyArg_ParseTuple(args, ":SetErrorHandler"))
     1802        return NULL;
     1803    Py_INCREF(Py_None);
     1804    return Py_None;
    18051805}
    18061806
    … …  
    18121812al_openport(PyObject *self, PyObject *args)
    18131813{
    1814         char *name, *dir;
    1815         ALport port;
    1816         alcobject *config = NULL;
    1817 
    1818         if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
    1819                 return NULL;
    1820         if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
    1821                 return NULL;
    1822         return newalpobject(port);
     1814    char *name, *dir;
     1815    ALport port;
     1816    alcobject *config = NULL;
     1817
     1818    if (!PyArg_ParseTuple(args, "ss|O!:OpenPort", &name, &dir, &Alctype, &config))
     1819        return NULL;
     1820    if ((port = ALopenport(name, dir, config ? config->config : NULL)) == NULL)
     1821        return NULL;
     1822    return newalpobject(port);
    18231823}
    18241824
    … …  
    18261826al_newconfig(PyObject *self, PyObject *args)
    18271827{
    1828         ALconfig config;
    1829 
    1830         if (!PyArg_ParseTuple(args, ":NewConfig"))
    1831                 return NULL;
    1832         if ((config = ALnewconfig ()) == NULL)
    1833                 return NULL;
    1834         return newalcobject(config);
     1828    ALconfig config;
     1829
     1830    if (!PyArg_ParseTuple(args, ":NewConfig"))
     1831        return NULL;
     1832    if ((config = ALnewconfig ()) == NULL)
     1833        return NULL;
     1834    return newalcobject(config);
    18351835}
    18361836
    … …  
    18381838al_queryparams(PyObject *self, PyObject *args)
    18391839{
    1840         long device;
    1841         long length;
    1842         long *PVbuffer;
    1843         long PVdummy[2];
    1844         PyObject *v = NULL;
    1845         int i;
    1846 
    1847         if (!PyArg_ParseTuple(args, "l:queryparams", &device))
    1848                 return NULL;
    1849         if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
    1850                 return NULL;
    1851         if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
    1852                 return PyErr_NoMemory();
    1853         if (ALqueryparams(device, PVbuffer, length) >= 0 &&
    1854             (v = PyList_New((int)length)) != NULL) {
    1855                 for (i = 0; i < length; i++)
    1856                         PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
    1857         }
    1858         PyMem_DEL(PVbuffer);
    1859         return v;
     1840    long device;
     1841    long length;
     1842    long *PVbuffer;
     1843    long PVdummy[2];
     1844    PyObject *v = NULL;
     1845    int i;
     1846
     1847    if (!PyArg_ParseTuple(args, "l:queryparams", &device))
     1848        return NULL;
     1849    if ((length = ALqueryparams(device, PVdummy, 2L)) == -1)
     1850        return NULL;
     1851    if ((PVbuffer = PyMem_NEW(long, length)) == NULL)
     1852        return PyErr_NoMemory();
     1853    if (ALqueryparams(device, PVbuffer, length) >= 0 &&
     1854        (v = PyList_New((int)length)) != NULL) {
     1855        for (i = 0; i < length; i++)
     1856            PyList_SetItem(v, i, PyInt_FromLong(PVbuffer[i]));
     1857    }
     1858    PyMem_DEL(PVbuffer);
     1859    return v;
    18601860}
    18611861
    … …  
    18631863doParams(PyObject *args, int (*func)(long, long *, long), int modified)
    18641864{
    1865         long device;
    1866         PyObject *list, *v;
    1867         long *PVbuffer;
    1868         long length;
    1869         int i;
    1870        
    1871         if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
    1872                 return NULL;
    1873         length = PyList_Size(list);
    1874         PVbuffer = PyMem_NEW(long, length);
    1875         if (PVbuffer == NULL)
    1876                 return PyErr_NoMemory();
    1877         for (i = 0; i < length; i++) {
    1878                 v = PyList_GetItem(list, i);
    1879                 if (!PyInt_Check(v)) {
    1880                         PyMem_DEL(PVbuffer);
    1881                         PyErr_BadArgument();
    1882                         return NULL;
    1883                 }
    1884                 PVbuffer[i] = PyInt_AsLong(v);
    1885         }
    1886 
    1887         if ((*func)(device, PVbuffer, length) == -1) {
    1888                 PyMem_DEL(PVbuffer);
    1889                 return NULL;
    1890         }
    1891 
    1892         if (modified) {
    1893                 for (i = 0; i < length; i++)
    1894                         PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
    1895         }
    1896 
    1897         PyMem_DEL(PVbuffer);
    1898 
    1899         Py_INCREF(Py_None);
    1900         return Py_None;
     1865    long device;
     1866    PyObject *list, *v;
     1867    long *PVbuffer;
     1868    long length;
     1869    int i;
     1870
     1871    if (!PyArg_ParseTuple(args, "lO!", &device, &PyList_Type, &list))
     1872        return NULL;
     1873    length = PyList_Size(list);
     1874    PVbuffer = PyMem_NEW(long, length);
     1875    if (PVbuffer == NULL)
     1876        return PyErr_NoMemory();
     1877    for (i = 0; i < length; i++) {
     1878        v = PyList_GetItem(list, i);
     1879        if (!PyInt_Check(v)) {
     1880            PyMem_DEL(PVbuffer);
     1881            PyErr_BadArgument();
     1882            return NULL;
     1883        }
     1884        PVbuffer[i] = PyInt_AsLong(v);
     1885    }
     1886
     1887    if ((*func)(device, PVbuffer, length) == -1) {
     1888        PyMem_DEL(PVbuffer);
     1889        return NULL;
     1890    }
     1891
     1892    if (modified) {
     1893        for (i = 0; i < length; i++)
     1894            PyList_SetItem(list, i, PyInt_FromLong(PVbuffer[i]));
     1895    }
     1896
     1897    PyMem_DEL(PVbuffer);
     1898
     1899    Py_INCREF(Py_None);
     1900    return Py_None;
    19011901}
    19021902
    … …  
    19041904al_getparams(PyObject *self, PyObject *args)
    19051905{
    1906         return doParams(args, ALgetparams, 1);
     1906    return doParams(args, ALgetparams, 1);
    19071907}
    19081908
    … …  
    19101910al_setparams(PyObject *self, PyObject *args)
    19111911{
    1912         return doParams(args, ALsetparams, 0);
     1912    return doParams(args, ALsetparams, 0);
    19131913}
    19141914
    … …  
    19161916al_getname(PyObject *self, PyObject *args)
    19171917{
    1918         long device, descriptor;
    1919         char *name;
    1920 
    1921         if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
    1922                 return NULL;
    1923         if ((name = ALgetname(device, descriptor)) == NULL)
    1924                 return NULL;
    1925         return PyString_FromString(name);
     1918    long device, descriptor;
     1919    char *name;
     1920
     1921    if (!PyArg_ParseTuple(args, "ll:getname", &device, &descriptor))
     1922        return NULL;
     1923    if ((name = ALgetname(device, descriptor)) == NULL)
     1924        return NULL;
     1925    return PyString_FromString(name);
    19261926}
    19271927
    … …  
    19291929al_getdefault(PyObject *self, PyObject *args)
    19301930{
    1931         long device, descriptor, value;
    1932 
    1933         if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
    1934                 return NULL;
    1935         if ((value = ALgetdefault(device, descriptor)) == -1)
    1936                 return NULL;
    1937         return PyLong_FromLong(value);
     1931    long device, descriptor, value;
     1932
     1933    if (!PyArg_ParseTuple(args, "ll:getdefault", &device, &descriptor))
     1934        return NULL;
     1935    if ((value = ALgetdefault(device, descriptor)) == -1)
     1936        return NULL;
     1937    return PyLong_FromLong(value);
    19381938}
    19391939
    … …  
    19411941al_getminmax(PyObject *self, PyObject *args)
    19421942{
    1943         long device, descriptor, min, max;
    1944 
    1945         if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
    1946                 return NULL;
    1947         min = -1;
    1948         max = -1;
    1949         if (ALgetminmax(device, descriptor, &min, &max) == -1)
    1950                 return NULL;
    1951         return Py_BuildValue("ll", min, max);
     1943    long device, descriptor, min, max;
     1944
     1945    if (!PyArg_ParseTuple(args, "ll:getminmax", &device, &descriptor))
     1946        return NULL;
     1947    min = -1;
     1948    max = -1;
     1949    if (ALgetminmax(device, descriptor, &min, &max) == -1)
     1950        return NULL;
     1951    return Py_BuildValue("ll", min, max);
    19521952}
    19531953
    … …  
    19571957
    19581958static struct PyMethodDef al_methods[] = {
    1959 #ifdef AL_NO_ELEM               /* IRIX 6 */
    1960         {"NewConfig",   (PyCFunction)al_NewConfig,      METH_VARARGS,   al_NewConfig__doc__},
    1961         {"OpenPort",    (PyCFunction)al_OpenPort,       METH_VARARGS,   al_OpenPort__doc__},
    1962         {"Connect",     (PyCFunction)al_Connect,        METH_VARARGS,   al_Connect__doc__},
    1963         {"Disconnect",  (PyCFunction)al_Disconnect,     METH_VARARGS,   al_Disconnect__doc__},
    1964         {"GetParams",   (PyCFunction)al_GetParams,      METH_VARARGS,   al_GetParams__doc__},
    1965         {"SetParams",   (PyCFunction)al_SetParams,      METH_VARARGS,   al_SetParams__doc__},
    1966         {"QueryValues", (PyCFunction)al_QueryValues,    METH_VARARGS,   al_QueryValues__doc__},
    1967         {"GetParamInfo",        (PyCFunction)al_GetParamInfo,   METH_VARARGS,   al_GetParamInfo__doc__},
    1968         {"GetResourceByName",   (PyCFunction)al_GetResourceByName,      METH_VARARGS,   al_GetResourceByName__doc__},
    1969         {"IsSubtype",   (PyCFunction)al_IsSubtype,      METH_VARARGS,   al_IsSubtype__doc__},
     1959#ifdef AL_NO_ELEM               /* IRIX 6 */
     1960    {"NewConfig",       (PyCFunction)al_NewConfig,      METH_VARARGS,   al_NewConfig__doc__},
     1961    {"OpenPort",        (PyCFunction)al_OpenPort,       METH_VARARGS,   al_OpenPort__doc__},
     1962    {"Connect",         (PyCFunction)al_Connect,        METH_VARARGS,   al_Connect__doc__},
     1963    {"Disconnect",      (PyCFunction)al_Disconnect,     METH_VARARGS,   al_Disconnect__doc__},
     1964    {"GetParams",       (PyCFunction)al_GetParams,      METH_VARARGS,   al_GetParams__doc__},
     1965    {"SetParams",       (PyCFunction)al_SetParams,      METH_VARARGS,   al_SetParams__doc__},
     1966    {"QueryValues",     (PyCFunction)al_QueryValues,    METH_VARARGS,   al_QueryValues__doc__},
     1967    {"GetParamInfo",            (PyCFunction)al_GetParamInfo,   METH_VARARGS,   al_GetParamInfo__doc__},
     1968    {"GetResourceByName",       (PyCFunction)al_GetResourceByName,      METH_VARARGS,   al_GetResourceByName__doc__},
     1969    {"IsSubtype",       (PyCFunction)al_IsSubtype,      METH_VARARGS,   al_IsSubtype__doc__},
    19701970#if 0
    1971         /* this one not supported */
    1972         {"SetErrorHandler",     (PyCFunction)al_SetErrorHandler,        METH_VARARGS,   al_SetErrorHandler__doc__},
     1971    /* this one not supported */
     1972    {"SetErrorHandler",         (PyCFunction)al_SetErrorHandler,        METH_VARARGS,   al_SetErrorHandler__doc__},
    19731973#endif
    19741974#endif /* AL_NO_ELEM */
    19751975#ifdef OLD_INTERFACE
    1976         {"openport",            (PyCFunction)al_openport,       METH_VARARGS},
    1977         {"newconfig",           (PyCFunction)al_newconfig,      METH_VARARGS},
    1978         {"queryparams",         (PyCFunction)al_queryparams,    METH_VARARGS},
    1979         {"getparams",           (PyCFunction)al_getparams,      METH_VARARGS},
    1980         {"setparams",           (PyCFunction)al_setparams,      METH_VARARGS},
    1981         {"getname",             (PyCFunction)al_getname,        METH_VARARGS},
    1982         {"getdefault",          (PyCFunction)al_getdefault,     METH_VARARGS},
    1983         {"getminmax",           (PyCFunction)al_getminmax,      METH_VARARGS},
     1976    {"openport",                (PyCFunction)al_openport,       METH_VARARGS},
     1977    {"newconfig",               (PyCFunction)al_newconfig,      METH_VARARGS},
     1978    {"queryparams",             (PyCFunction)al_queryparams,    METH_VARARGS},
     1979    {"getparams",               (PyCFunction)al_getparams,      METH_VARARGS},
     1980    {"setparams",               (PyCFunction)al_setparams,      METH_VARARGS},
     1981    {"getname",                 (PyCFunction)al_getname,        METH_VARARGS},
     1982    {"getdefault",              (PyCFunction)al_getdefault,     METH_VARARGS},
     1983    {"getminmax",               (PyCFunction)al_getminmax,      METH_VARARGS},
    19841984#endif /* OLD_INTERFACE */
    19851985
    1986         {NULL,   (PyCFunction)NULL, 0, NULL}            /* sentinel */
     1986    {NULL,       (PyCFunction)NULL, 0, NULL}            /* sentinel */
    19871987};
    19881988
    … …  
    19951995inital(void)
    19961996{
    1997         PyObject *m, *d, *x;
    1998 
    1999         if (PyErr_WarnPy3k("the al module has been removed in "
    2000                            "Python 3.0", 2) < 0)
    2001             return;     
    2002 
    2003         /* Create the module and add the functions */
    2004         m = Py_InitModule4("al", al_methods,
    2005                 al_module_documentation,
    2006                 (PyObject*)NULL,PYTHON_API_VERSION);
    2007         if (m == NULL)
    2008                 return;
    2009 
    2010         /* Add some symbolic constants to the module */
    2011         d = PyModule_GetDict(m);
    2012         ErrorObject = PyErr_NewException("al.error", NULL, NULL);
    2013         PyDict_SetItemString(d, "error", ErrorObject);
    2014 
    2015         /* XXXX Add constants here */
     1997    PyObject *m, *d, *x;
     1998
     1999    if (PyErr_WarnPy3k("the al module has been removed in "
     2000                       "Python 3.0", 2) < 0)
     2001        return;
     2002
     2003    /* Create the module and add the functions */
     2004    m = Py_InitModule4("al", al_methods,
     2005        al_module_documentation,
     2006        (PyObject*)NULL,PYTHON_API_VERSION);
     2007    if (m == NULL)
     2008        return;
     2009
     2010    /* Add some symbolic constants to the module */
     2011    d = PyModule_GetDict(m);
     2012    ErrorObject = PyErr_NewException("al.error", NULL, NULL);
     2013    PyDict_SetItemString(d, "error", ErrorObject);
     2014
     2015    /* XXXX Add constants here */
    20162016#ifdef AL_4CHANNEL
    2017         x =  PyInt_FromLong((long) AL_4CHANNEL);
    2018         if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
    2019                 goto error;
    2020         Py_DECREF(x);
     2017    x =  PyInt_FromLong((long) AL_4CHANNEL);
     2018    if (x == NULL || PyDict_SetItemString(d, "FOURCHANNEL", x) < 0)
     2019        goto error;
     2020    Py_DECREF(x);
    20212021#endif
    20222022#ifdef AL_ADAT_IF_TYPE
    2023         x =  PyInt_FromLong((long) AL_ADAT_IF_TYPE);
    2024         if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
    2025                 goto error;
    2026         Py_DECREF(x);
     2023    x =  PyInt_FromLong((long) AL_ADAT_IF_TYPE);
     2024    if (x == NULL || PyDict_SetItemString(d, "ADAT_IF_TYPE", x) < 0)
     2025        goto error;
     2026    Py_DECREF(x);
    20272027#endif
    20282028#ifdef AL_ADAT_MCLK_TYPE
    2029         x =  PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
    2030         if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
    2031                 goto error;
    2032         Py_DECREF(x);
     2029    x =  PyInt_FromLong((long) AL_ADAT_MCLK_TYPE);
     2030    if (x == NULL || PyDict_SetItemString(d, "ADAT_MCLK_TYPE", x) < 0)
     2031        goto error;
     2032    Py_DECREF(x);
    20332033#endif
    20342034#ifdef AL_AES_IF_TYPE
    2035         x =  PyInt_FromLong((long) AL_AES_IF_TYPE);
    2036         if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
    2037                 goto error;
    2038         Py_DECREF(x);
     2035    x =  PyInt_FromLong((long) AL_AES_IF_TYPE);
     2036    if (x == NULL || PyDict_SetItemString(d, "AES_IF_TYPE", x) < 0)
     2037        goto error;
     2038    Py_DECREF(x);
    20392039#endif
    20402040#ifdef AL_AES_MCLK_TYPE
    2041         x =  PyInt_FromLong((long) AL_AES_MCLK_TYPE);
    2042         if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
    2043                 goto error;
    2044         Py_DECREF(x);
     2041    x =  PyInt_FromLong((long) AL_AES_MCLK_TYPE);
     2042    if (x == NULL || PyDict_SetItemString(d, "AES_MCLK_TYPE", x) < 0)
     2043        goto error;
     2044    Py_DECREF(x);
    20452045#endif
    20462046#ifdef AL_ANALOG_IF_TYPE
    2047         x =  PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
    2048         if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
    2049                 goto error;
    2050         Py_DECREF(x);
     2047    x =  PyInt_FromLong((long) AL_ANALOG_IF_TYPE);
     2048    if (x == NULL || PyDict_SetItemString(d, "ANALOG_IF_TYPE", x) < 0)
     2049        goto error;
     2050    Py_DECREF(x);
    20512051#endif
    20522052#ifdef AL_ASSOCIATE
    2053         x =  PyInt_FromLong((long) AL_ASSOCIATE);
    2054         if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
    2055                 goto error;
    2056         Py_DECREF(x);
     2053    x =  PyInt_FromLong((long) AL_ASSOCIATE);
     2054    if (x == NULL || PyDict_SetItemString(d, "ASSOCIATE", x) < 0)
     2055        goto error;
     2056    Py_DECREF(x);
    20572057#endif
    20582058#ifdef AL_BAD_BUFFER_NULL
    2059         x =  PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
    2060         if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
    2061                 goto error;
    2062         Py_DECREF(x);
     2059    x =  PyInt_FromLong((long) AL_BAD_BUFFER_NULL);
     2060    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFER_NULL", x) < 0)
     2061        goto error;
     2062    Py_DECREF(x);
    20632063#endif
    20642064#ifdef AL_BAD_BUFFERLENGTH
    2065         x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
    2066         if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
    2067                 goto error;
    2068         Py_DECREF(x);
     2065    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH);
     2066    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH", x) < 0)
     2067        goto error;
     2068    Py_DECREF(x);
    20692069#endif
    20702070#ifdef AL_BAD_BUFFERLENGTH_NEG
    2071         x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
    2072         if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
    2073                 goto error;
    2074         Py_DECREF(x);
     2071    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_NEG);
     2072    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_NEG", x) < 0)
     2073        goto error;
     2074    Py_DECREF(x);
    20752075#endif
    20762076#ifdef AL_BAD_BUFFERLENGTH_ODD
    2077         x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
    2078         if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
    2079                 goto error;
    2080         Py_DECREF(x);
     2077    x =  PyInt_FromLong((long) AL_BAD_BUFFERLENGTH_ODD);
     2078    if (x == NULL || PyDict_SetItemString(d, "BAD_BUFFERLENGTH_ODD", x) < 0)
     2079        goto error;
     2080    Py_DECREF(x);
    20812081#endif
    20822082#ifdef AL_BAD_CHANNELS
    2083         x =  PyInt_FromLong((long) AL_BAD_CHANNELS);
    2084         if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
    2085                 goto error;
    2086         Py_DECREF(x);
     2083    x =  PyInt_FromLong((long) AL_BAD_CHANNELS);
     2084    if (x == NULL || PyDict_SetItemString(d, "BAD_CHANNELS", x) < 0)
     2085        goto error;
     2086    Py_DECREF(x);
    20872087#endif
    20882088#ifdef AL_BAD_CONFIG
    2089         x =  PyInt_FromLong((long) AL_BAD_CONFIG);
    2090         if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
    2091                 goto error;
    2092         Py_DECREF(x);
     2089    x =  PyInt_FromLong((long) AL_BAD_CONFIG);
     2090    if (x == NULL || PyDict_SetItemString(d, "BAD_CONFIG", x) < 0)
     2091        goto error;
     2092    Py_DECREF(x);
    20932093#endif
    20942094#ifdef AL_BAD_COUNT_NEG
    2095         x =  PyInt_FromLong((long) AL_BAD_COUNT_NEG);
    2096         if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
    2097                 goto error;
    2098         Py_DECREF(x);
     2095    x =  PyInt_FromLong((long) AL_BAD_COUNT_NEG);
     2096    if (x == NULL || PyDict_SetItemString(d, "BAD_COUNT_NEG", x) < 0)
     2097        goto error;
     2098    Py_DECREF(x);
    20992099#endif
    21002100#ifdef AL_BAD_DEVICE
    2101         x =  PyInt_FromLong((long) AL_BAD_DEVICE);
    2102         if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
    2103                 goto error;
    2104         Py_DECREF(x);
     2101    x =  PyInt_FromLong((long) AL_BAD_DEVICE);
     2102    if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE", x) < 0)
     2103        goto error;
     2104    Py_DECREF(x);
    21052105#endif
    21062106#ifdef AL_BAD_DEVICE_ACCESS
    2107         x =  PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
    2108         if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
    2109                 goto error;
    2110         Py_DECREF(x);
     2107    x =  PyInt_FromLong((long) AL_BAD_DEVICE_ACCESS);
     2108    if (x == NULL || PyDict_SetItemString(d, "BAD_DEVICE_ACCESS", x) < 0)
     2109        goto error;
     2110    Py_DECREF(x);
    21112111#endif
    21122112#ifdef AL_BAD_DIRECTION
    2113         x =  PyInt_FromLong((long) AL_BAD_DIRECTION);
    2114         if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
    2115                 goto error;
    2116         Py_DECREF(x);
     2113    x =  PyInt_FromLong((long) AL_BAD_DIRECTION);
     2114    if (x == NULL || PyDict_SetItemString(d, "BAD_DIRECTION", x) < 0)
     2115        goto error;
     2116    Py_DECREF(x);
    21172117#endif
    21182118#ifdef AL_BAD_FILLPOINT
    2119         x =  PyInt_FromLong((long) AL_BAD_FILLPOINT);
    2120         if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
    2121                 goto error;
    2122         Py_DECREF(x);
     2119    x =  PyInt_FromLong((long) AL_BAD_FILLPOINT);
     2120    if (x == NULL || PyDict_SetItemString(d, "BAD_FILLPOINT", x) < 0)
     2121        goto error;
     2122    Py_DECREF(x);
    21232123#endif
    21242124#ifdef AL_BAD_FLOATMAX
    2125         x =  PyInt_FromLong((long) AL_BAD_FLOATMAX);
    2126         if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
    2127                 goto error;
    2128         Py_DECREF(x);
     2125    x =  PyInt_FromLong((long) AL_BAD_FLOATMAX);
     2126    if (x == NULL || PyDict_SetItemString(d, "BAD_FLOATMAX", x) < 0)
     2127        goto error;
     2128    Py_DECREF(x);
    21292129#endif
    21302130#ifdef AL_BAD_ILLEGAL_STATE
    2131         x =  PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
    2132         if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
    2133                 goto error;
    2134         Py_DECREF(x);
     2131    x =  PyInt_FromLong((long) AL_BAD_ILLEGAL_STATE);
     2132    if (x == NULL || PyDict_SetItemString(d, "BAD_ILLEGAL_STATE", x) < 0)
     2133        goto error;
     2134    Py_DECREF(x);
    21352135#endif
    21362136#ifdef AL_BAD_NO_PORTS
    2137         x =  PyInt_FromLong((long) AL_BAD_NO_PORTS);
    2138         if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
    2139                 goto error;
    2140         Py_DECREF(x);
     2137    x =  PyInt_FromLong((long) AL_BAD_NO_PORTS);
     2138    if (x == NULL || PyDict_SetItemString(d, "BAD_NO_PORTS", x) < 0)
     2139        goto error;
     2140    Py_DECREF(x);
    21412141#endif
    21422142#ifdef AL_BAD_NOT_FOUND
    2143         x =  PyInt_FromLong((long) AL_BAD_NOT_FOUND);
    2144         if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
    2145                 goto error;
    2146         Py_DECREF(x);
     2143    x =  PyInt_FromLong((long) AL_BAD_NOT_FOUND);
     2144    if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_FOUND", x) < 0)
     2145        goto error;
     2146    Py_DECREF(x);
    21472147#endif
    21482148#ifdef AL_BAD_NOT_IMPLEMENTED
    2149         x =  PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
    2150         if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
    2151                 goto error;
    2152         Py_DECREF(x);
     2149    x =  PyInt_FromLong((long) AL_BAD_NOT_IMPLEMENTED);
     2150    if (x == NULL || PyDict_SetItemString(d, "BAD_NOT_IMPLEMENTED", x) < 0)
     2151        goto error;
     2152    Py_DECREF(x);
    21532153#endif
    21542154#ifdef AL_BAD_OUT_OF_MEM
    2155         x =  PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
    2156         if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
    2157                 goto error;
    2158         Py_DECREF(x);
     2155    x =  PyInt_FromLong((long) AL_BAD_OUT_OF_MEM);
     2156    if (x == NULL || PyDict_SetItemString(d, "BAD_OUT_OF_MEM", x) < 0)
     2157        goto error;
     2158    Py_DECREF(x);
    21592159#endif
    21602160#ifdef AL_BAD_PARAM
    2161         x =  PyInt_FromLong((long) AL_BAD_PARAM);
    2162         if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
    2163                 goto error;
    2164         Py_DECREF(x);
     2161    x =  PyInt_FromLong((long) AL_BAD_PARAM);
     2162    if (x == NULL || PyDict_SetItemString(d, "BAD_PARAM", x) < 0)
     2163        goto error;
     2164    Py_DECREF(x);
    21652165#endif
    21662166#ifdef AL_BAD_PERMISSIONS
    2167         x =  PyInt_FromLong((long) AL_BAD_PERMISSIONS);
    2168         if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
    2169                 goto error;
    2170         Py_DECREF(x);
     2167    x =  PyInt_FromLong((long) AL_BAD_PERMISSIONS);
     2168    if (x == NULL || PyDict_SetItemString(d, "BAD_PERMISSIONS", x) < 0)
     2169        goto error;
     2170    Py_DECREF(x);
    21712171#endif
    21722172#ifdef AL_BAD_PORT
    2173         x =  PyInt_FromLong((long) AL_BAD_PORT);
    2174         if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
    2175                 goto error;
    2176         Py_DECREF(x);
     2173    x =  PyInt_FromLong((long) AL_BAD_PORT);
     2174    if (x == NULL || PyDict_SetItemString(d, "BAD_PORT", x) < 0)
     2175        goto error;
     2176    Py_DECREF(x);
    21772177#endif
    21782178#ifdef AL_BAD_PORTSTYLE
    2179         x =  PyInt_FromLong((long) AL_BAD_PORTSTYLE);
    2180         if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
    2181                 goto error;
    2182         Py_DECREF(x);
     2179    x =  PyInt_FromLong((long) AL_BAD_PORTSTYLE);
     2180    if (x == NULL || PyDict_SetItemString(d, "BAD_PORTSTYLE", x) < 0)
     2181        goto error;
     2182    Py_DECREF(x);
    21832183#endif
    21842184#ifdef AL_BAD_PVBUFFER
    2185         x =  PyInt_FromLong((long) AL_BAD_PVBUFFER);
    2186         if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
    2187                 goto error;
    2188         Py_DECREF(x);
     2185    x =  PyInt_FromLong((long) AL_BAD_PVBUFFER);
     2186    if (x == NULL || PyDict_SetItemString(d, "BAD_PVBUFFER", x) < 0)
     2187        goto error;
     2188    Py_DECREF(x);
    21892189#endif
    21902190#ifdef AL_BAD_QSIZE
    2191         x =  PyInt_FromLong((long) AL_BAD_QSIZE);
    2192         if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
    2193                 goto error;
    2194         Py_DECREF(x);
     2191    x =  PyInt_FromLong((long) AL_BAD_QSIZE);
     2192    if (x == NULL || PyDict_SetItemString(d, "BAD_QSIZE", x) < 0)
     2193        goto error;
     2194    Py_DECREF(x);
    21952195#endif
    21962196#ifdef AL_BAD_RATE
    2197         x =  PyInt_FromLong((long) AL_BAD_RATE);
    2198         if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
    2199                 goto error;
    2200         Py_DECREF(x);
     2197    x =  PyInt_FromLong((long) AL_BAD_RATE);
     2198    if (x == NULL || PyDict_SetItemString(d, "BAD_RATE", x) < 0)
     2199        goto error;
     2200    Py_DECREF(x);
    22012201#endif
    22022202#ifdef AL_BAD_RESOURCE
    2203         x =  PyInt_FromLong((long) AL_BAD_RESOURCE);
    2204         if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
    2205                 goto error;
    2206         Py_DECREF(x);
     2203    x =  PyInt_FromLong((long) AL_BAD_RESOURCE);
     2204    if (x == NULL || PyDict_SetItemString(d, "BAD_RESOURCE", x) < 0)
     2205        goto error;
     2206    Py_DECREF(x);
    22072207#endif
    22082208#ifdef AL_BAD_SAMPFMT
    2209         x =  PyInt_FromLong((long) AL_BAD_SAMPFMT);
    2210         if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
    2211                 goto error;
    2212         Py_DECREF(x);
     2209    x =  PyInt_FromLong((long) AL_BAD_SAMPFMT);
     2210    if (x == NULL || PyDict_SetItemString(d, "BAD_SAMPFMT", x) < 0)
     2211        goto error;
     2212    Py_DECREF(x);
    22132213#endif
    22142214#ifdef AL_BAD_TRANSFER_SIZE
    2215         x =  PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
    2216         if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
    2217                 goto error;
    2218         Py_DECREF(x);
     2215    x =  PyInt_FromLong((long) AL_BAD_TRANSFER_SIZE);
     2216    if (x == NULL || PyDict_SetItemString(d, "BAD_TRANSFER_SIZE", x) < 0)
     2217        goto error;
     2218    Py_DECREF(x);
    22192219#endif
    22202220#ifdef AL_BAD_WIDTH
    2221         x =  PyInt_FromLong((long) AL_BAD_WIDTH);
    2222         if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
    2223                 goto error;
    2224         Py_DECREF(x);
     2221    x =  PyInt_FromLong((long) AL_BAD_WIDTH);
     2222    if (x == NULL || PyDict_SetItemString(d, "BAD_WIDTH", x) < 0)
     2223        goto error;
     2224    Py_DECREF(x);
    22252225#endif
    22262226#ifdef AL_CHANNEL_MODE
    2227         x =  PyInt_FromLong((long) AL_CHANNEL_MODE);
    2228         if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
    2229                 goto error;
    2230         Py_DECREF(x);
     2227    x =  PyInt_FromLong((long) AL_CHANNEL_MODE);
     2228    if (x == NULL || PyDict_SetItemString(d, "CHANNEL_MODE", x) < 0)
     2229        goto error;
     2230    Py_DECREF(x);
    22312231#endif
    22322232#ifdef AL_CHANNELS
    2233         x =  PyInt_FromLong((long) AL_CHANNELS);
    2234         if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
    2235                 goto error;
    2236         Py_DECREF(x);
     2233    x =  PyInt_FromLong((long) AL_CHANNELS);
     2234    if (x == NULL || PyDict_SetItemString(d, "CHANNELS", x) < 0)
     2235        goto error;
     2236    Py_DECREF(x);
    22372237#endif
    22382238#ifdef AL_CHAR_ELEM
    2239         x =  PyInt_FromLong((long) AL_CHAR_ELEM);
    2240         if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
    2241                 goto error;
    2242         Py_DECREF(x);
     2239    x =  PyInt_FromLong((long) AL_CHAR_ELEM);
     2240    if (x == NULL || PyDict_SetItemString(d, "CHAR_ELEM", x) < 0)
     2241        goto error;
     2242    Py_DECREF(x);
    22432243#endif
    22442244#ifdef AL_CLOCK_GEN
    2245         x =  PyInt_FromLong((long) AL_CLOCK_GEN);
    2246         if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
    2247                 goto error;
    2248         Py_DECREF(x);
     2245    x =  PyInt_FromLong((long) AL_CLOCK_GEN);
     2246    if (x == NULL || PyDict_SetItemString(d, "CLOCK_GEN", x) < 0)
     2247        goto error;
     2248    Py_DECREF(x);
    22492249#endif
    22502250#ifdef AL_CLOCKGEN_TYPE
    2251         x =  PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
    2252         if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
    2253                 goto error;
    2254         Py_DECREF(x);
     2251    x =  PyInt_FromLong((long) AL_CLOCKGEN_TYPE);
     2252    if (x == NULL || PyDict_SetItemString(d, "CLOCKGEN_TYPE", x) < 0)
     2253        goto error;
     2254    Py_DECREF(x);
    22552255#endif
    22562256#ifdef AL_CONNECT
    2257         x =  PyInt_FromLong((long) AL_CONNECT);
    2258         if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
    2259                 goto error;
    2260         Py_DECREF(x);
     2257    x =  PyInt_FromLong((long) AL_CONNECT);
     2258    if (x == NULL || PyDict_SetItemString(d, "CONNECT", x) < 0)
     2259        goto error;
     2260    Py_DECREF(x);
    22612261#endif
    22622262#ifdef AL_CONNECTION_TYPE
    2263         x =  PyInt_FromLong((long) AL_CONNECTION_TYPE);
    2264         if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
    2265                 goto error;
    2266         Py_DECREF(x);
     2263    x =  PyInt_FromLong((long) AL_CONNECTION_TYPE);
     2264    if (x == NULL || PyDict_SetItemString(d, "CONNECTION_TYPE", x) < 0)
     2265        goto error;
     2266    Py_DECREF(x);
    22672267#endif
    22682268#ifdef AL_CONNECTIONS
    2269         x =  PyInt_FromLong((long) AL_CONNECTIONS);
    2270         if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
    2271                 goto error;
    2272         Py_DECREF(x);
     2269    x =  PyInt_FromLong((long) AL_CONNECTIONS);
     2270    if (x == NULL || PyDict_SetItemString(d, "CONNECTIONS", x) < 0)
     2271        goto error;
     2272    Py_DECREF(x);
    22732273#endif
    22742274#ifdef AL_CRYSTAL_MCLK_TYPE
    2275         x =  PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
    2276         if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
    2277                 goto error;
    2278         Py_DECREF(x);
     2275    x =  PyInt_FromLong((long) AL_CRYSTAL_MCLK_TYPE);
     2276    if (x == NULL || PyDict_SetItemString(d, "CRYSTAL_MCLK_TYPE", x) < 0)
     2277        goto error;
     2278    Py_DECREF(x);
    22792279#endif
    22802280#ifdef AL_DEFAULT_DEVICE
    2281         x =  PyInt_FromLong((long) AL_DEFAULT_DEVICE);
    2282         if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
    2283                 goto error;
    2284         Py_DECREF(x);
     2281    x =  PyInt_FromLong((long) AL_DEFAULT_DEVICE);
     2282    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_DEVICE", x) < 0)
     2283        goto error;
     2284    Py_DECREF(x);
    22852285#endif
    22862286#ifdef AL_DEFAULT_INPUT
    2287         x =  PyInt_FromLong((long) AL_DEFAULT_INPUT);
    2288         if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
    2289                 goto error;
    2290         Py_DECREF(x);
     2287    x =  PyInt_FromLong((long) AL_DEFAULT_INPUT);
     2288    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_INPUT", x) < 0)
     2289        goto error;
     2290    Py_DECREF(x);
    22912291#endif
    22922292#ifdef AL_DEFAULT_OUTPUT
    2293         x =  PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
    2294         if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
    2295                 goto error;
    2296         Py_DECREF(x);
     2293    x =  PyInt_FromLong((long) AL_DEFAULT_OUTPUT);
     2294    if (x == NULL || PyDict_SetItemString(d, "DEFAULT_OUTPUT", x) < 0)
     2295        goto error;
     2296    Py_DECREF(x);
    22972297#endif
    22982298#ifdef AL_DEST
    2299         x =  PyInt_FromLong((long) AL_DEST);
    2300         if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
    2301                 goto error;
    2302         Py_DECREF(x);
     2299    x =  PyInt_FromLong((long) AL_DEST);
     2300    if (x == NULL || PyDict_SetItemString(d, "DEST", x) < 0)
     2301        goto error;
     2302    Py_DECREF(x);
    23032303#endif
    23042304#ifdef AL_DEVICE_TYPE
    2305         x =  PyInt_FromLong((long) AL_DEVICE_TYPE);
    2306         if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
    2307                 goto error;
    2308         Py_DECREF(x);
     2305    x =  PyInt_FromLong((long) AL_DEVICE_TYPE);
     2306    if (x == NULL || PyDict_SetItemString(d, "DEVICE_TYPE", x) < 0)
     2307        goto error;
     2308    Py_DECREF(x);
    23092309#endif
    23102310#ifdef AL_DEVICES
    2311         x =  PyInt_FromLong((long) AL_DEVICES);
    2312         if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
    2313                 goto error;
    2314         Py_DECREF(x);
     2311    x =  PyInt_FromLong((long) AL_DEVICES);
     2312    if (x == NULL || PyDict_SetItemString(d, "DEVICES", x) < 0)
     2313        goto error;
     2314    Py_DECREF(x);
    23152315#endif
    23162316#ifdef AL_DIGITAL_IF_TYPE
    2317         x =  PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
    2318         if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
    2319                 goto error;
    2320         Py_DECREF(x);
     2317    x =  PyInt_FromLong((long) AL_DIGITAL_IF_TYPE);
     2318    if (x == NULL || PyDict_SetItemString(d, "DIGITAL_IF_TYPE", x) < 0)
     2319        goto error;
     2320    Py_DECREF(x);
    23212321#endif
    23222322#ifdef AL_DIGITAL_INPUT_RATE
    2323         x =  PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
    2324         if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
    2325                 goto error;
    2326         Py_DECREF(x);
     2323    x =  PyInt_FromLong((long) AL_DIGITAL_INPUT_RATE);
     2324    if (x == NULL || PyDict_SetItemString(d, "DIGITAL_INPUT_RATE", x) < 0)
     2325        goto error;
     2326    Py_DECREF(x);
    23272327#endif
    23282328#ifdef AL_DISCONNECT
    2329         x =  PyInt_FromLong((long) AL_DISCONNECT);
    2330         if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
    2331                 goto error;
    2332         Py_DECREF(x);
     2329    x =  PyInt_FromLong((long) AL_DISCONNECT);
     2330    if (x == NULL || PyDict_SetItemString(d, "DISCONNECT", x) < 0)
     2331        goto error;
     2332    Py_DECREF(x);
    23332333#endif
    23342334#ifdef AL_ENUM_ELEM
    2335         x =  PyInt_FromLong((long) AL_ENUM_ELEM);
    2336         if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
    2337                 goto error;
    2338         Py_DECREF(x);
     2335    x =  PyInt_FromLong((long) AL_ENUM_ELEM);
     2336    if (x == NULL || PyDict_SetItemString(d, "ENUM_ELEM", x) < 0)
     2337        goto error;
     2338    Py_DECREF(x);
    23392339#endif
    23402340#ifdef AL_ENUM_VALUE
    2341         x =  PyInt_FromLong((long) AL_ENUM_VALUE);
    2342         if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
    2343                 goto error;
    2344         Py_DECREF(x);
     2341    x =  PyInt_FromLong((long) AL_ENUM_VALUE);
     2342    if (x == NULL || PyDict_SetItemString(d, "ENUM_VALUE", x) < 0)
     2343        goto error;
     2344    Py_DECREF(x);
    23452345#endif
    23462346#ifdef AL_ERROR_INPUT_OVERFLOW
    2347         x =  PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
    2348         if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
    2349                 goto error;
    2350         Py_DECREF(x);
     2347    x =  PyInt_FromLong((long) AL_ERROR_INPUT_OVERFLOW);
     2348    if (x == NULL || PyDict_SetItemString(d, "ERROR_INPUT_OVERFLOW", x) < 0)
     2349        goto error;
     2350    Py_DECREF(x);
    23512351#endif
    23522352#ifdef AL_ERROR_LENGTH
    2353         x =  PyInt_FromLong((long) AL_ERROR_LENGTH);
    2354         if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
    2355                 goto error;
    2356         Py_DECREF(x);
     2353    x =  PyInt_FromLong((long) AL_ERROR_LENGTH);
     2354    if (x == NULL || PyDict_SetItemString(d, "ERROR_LENGTH", x) < 0)
     2355        goto error;
     2356    Py_DECREF(x);
    23572357#endif
    23582358#ifdef AL_ERROR_LOCATION_LSP
    2359         x =  PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
    2360         if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
    2361                 goto error;
    2362         Py_DECREF(x);
     2359    x =  PyInt_FromLong((long) AL_ERROR_LOCATION_LSP);
     2360    if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_LSP", x) < 0)
     2361        goto error;
     2362    Py_DECREF(x);
    23632363#endif
    23642364#ifdef AL_ERROR_LOCATION_MSP
    2365         x =  PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
    2366         if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
    2367                 goto error;
    2368         Py_DECREF(x);
     2365    x =  PyInt_FromLong((long) AL_ERROR_LOCATION_MSP);
     2366    if (x == NULL || PyDict_SetItemString(d, "ERROR_LOCATION_MSP", x) < 0)
     2367        goto error;
     2368    Py_DECREF(x);
    23692369#endif
    23702370#ifdef AL_ERROR_NUMBER
    2371         x =  PyInt_FromLong((long) AL_ERROR_NUMBER);
    2372         if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
    2373                 goto error;
    2374         Py_DECREF(x);
     2371    x =  PyInt_FromLong((long) AL_ERROR_NUMBER);
     2372    if (x == NULL || PyDict_SetItemString(d, "ERROR_NUMBER", x) < 0)
     2373        goto error;
     2374    Py_DECREF(x);
    23752375#endif
    23762376#ifdef AL_ERROR_OUTPUT_UNDERFLOW
    2377         x =  PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
    2378         if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
    2379                 goto error;
    2380         Py_DECREF(x);
     2377    x =  PyInt_FromLong((long) AL_ERROR_OUTPUT_UNDERFLOW);
     2378    if (x == NULL || PyDict_SetItemString(d, "ERROR_OUTPUT_UNDERFLOW", x) < 0)
     2379        goto error;
     2380    Py_DECREF(x);
    23812381#endif
    23822382#ifdef AL_ERROR_TYPE
    2383         x =  PyInt_FromLong((long) AL_ERROR_TYPE);
    2384         if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
    2385                 goto error;
    2386         Py_DECREF(x);
     2383    x =  PyInt_FromLong((long) AL_ERROR_TYPE);
     2384    if (x == NULL || PyDict_SetItemString(d, "ERROR_TYPE", x) < 0)
     2385        goto error;
     2386    Py_DECREF(x);
    23872387#endif
    23882388#ifdef AL_FIXED_ELEM
    2389         x =  PyInt_FromLong((long) AL_FIXED_ELEM);
    2390         if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
    2391                 goto error;
    2392         Py_DECREF(x);
     2389    x =  PyInt_FromLong((long) AL_FIXED_ELEM);
     2390    if (x == NULL || PyDict_SetItemString(d, "FIXED_ELEM", x) < 0)
     2391        goto error;
     2392    Py_DECREF(x);
    23932393#endif
    23942394#ifdef AL_FIXED_MCLK_TYPE
    2395         x =  PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
    2396         if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
    2397                 goto error;
    2398         Py_DECREF(x);
     2395    x =  PyInt_FromLong((long) AL_FIXED_MCLK_TYPE);
     2396    if (x == NULL || PyDict_SetItemString(d, "FIXED_MCLK_TYPE", x) < 0)
     2397        goto error;
     2398    Py_DECREF(x);
    23992399#endif
    24002400#ifdef AL_GAIN
    2401         x =  PyInt_FromLong((long) AL_GAIN);
    2402         if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
    2403                 goto error;
    2404         Py_DECREF(x);
     2401    x =  PyInt_FromLong((long) AL_GAIN);
     2402    if (x == NULL || PyDict_SetItemString(d, "GAIN", x) < 0)
     2403        goto error;
     2404    Py_DECREF(x);
    24052405#endif
    24062406#ifdef AL_GAIN_REF
    2407         x =  PyInt_FromLong((long) AL_GAIN_REF);
    2408         if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
    2409                 goto error;
    2410         Py_DECREF(x);
     2407    x =  PyInt_FromLong((long) AL_GAIN_REF);
     2408    if (x == NULL || PyDict_SetItemString(d, "GAIN_REF", x) < 0)
     2409        goto error;
     2410    Py_DECREF(x);
    24112411#endif
    24122412#ifdef AL_HRB_TYPE
    2413         x =  PyInt_FromLong((long) AL_HRB_TYPE);
    2414         if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
    2415                 goto error;
    2416         Py_DECREF(x);
     2413    x =  PyInt_FromLong((long) AL_HRB_TYPE);
     2414    if (x == NULL || PyDict_SetItemString(d, "HRB_TYPE", x) < 0)
     2415        goto error;
     2416    Py_DECREF(x);
    24172417#endif
    24182418#ifdef AL_INPUT_COUNT
    2419         x =  PyInt_FromLong((long) AL_INPUT_COUNT);
    2420         if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
    2421                 goto error;
    2422         Py_DECREF(x);
     2419    x =  PyInt_FromLong((long) AL_INPUT_COUNT);
     2420    if (x == NULL || PyDict_SetItemString(d, "INPUT_COUNT", x) < 0)
     2421        goto error;
     2422    Py_DECREF(x);
    24232423#endif
    24242424#ifdef AL_INPUT_DEVICE_TYPE
    2425         x =  PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
    2426         if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
    2427                 goto error;
    2428         Py_DECREF(x);
     2425    x =  PyInt_FromLong((long) AL_INPUT_DEVICE_TYPE);
     2426    if (x == NULL || PyDict_SetItemString(d, "INPUT_DEVICE_TYPE", x) < 0)
     2427        goto error;
     2428    Py_DECREF(x);
    24292429#endif
    24302430#ifdef AL_INPUT_DIGITAL
    2431         x =  PyInt_FromLong((long) AL_INPUT_DIGITAL);
    2432         if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
    2433                 goto error;
    2434         Py_DECREF(x);
     2431    x =  PyInt_FromLong((long) AL_INPUT_DIGITAL);
     2432    if (x == NULL || PyDict_SetItemString(d, "INPUT_DIGITAL", x) < 0)
     2433        goto error;
     2434    Py_DECREF(x);
    24352435#endif
    24362436#ifdef AL_INPUT_HRB_TYPE
    2437         x =  PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
    2438         if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
    2439                 goto error;
    2440         Py_DECREF(x);
     2437    x =  PyInt_FromLong((long) AL_INPUT_HRB_TYPE);
     2438    if (x == NULL || PyDict_SetItemString(d, "INPUT_HRB_TYPE", x) < 0)
     2439        goto error;
     2440    Py_DECREF(x);
    24412441#endif
    24422442#ifdef AL_INPUT_LINE
    2443         x =  PyInt_FromLong((long) AL_INPUT_LINE);
    2444         if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
    2445                 goto error;
    2446         Py_DECREF(x);
     2443    x =  PyInt_FromLong((long) AL_INPUT_LINE);
     2444    if (x == NULL || PyDict_SetItemString(d, "INPUT_LINE", x) < 0)
     2445        goto error;
     2446    Py_DECREF(x);
    24472447#endif
    24482448#ifdef AL_INPUT_MIC
    2449         x =  PyInt_FromLong((long) AL_INPUT_MIC);
    2450         if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
    2451                 goto error;
    2452         Py_DECREF(x);
     2449    x =  PyInt_FromLong((long) AL_INPUT_MIC);
     2450    if (x == NULL || PyDict_SetItemString(d, "INPUT_MIC", x) < 0)
     2451        goto error;
     2452    Py_DECREF(x);
    24532453#endif
    24542454#ifdef AL_INPUT_PORT_TYPE
    2455         x =  PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
    2456         if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
    2457                 goto error;
    2458         Py_DECREF(x);
     2455    x =  PyInt_FromLong((long) AL_INPUT_PORT_TYPE);
     2456    if (x == NULL || PyDict_SetItemString(d, "INPUT_PORT_TYPE", x) < 0)
     2457        goto error;
     2458    Py_DECREF(x);
    24592459#endif
    24602460#ifdef AL_INPUT_RATE
    2461         x =  PyInt_FromLong((long) AL_INPUT_RATE);
    2462         if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
    2463                 goto error;
    2464         Py_DECREF(x);
     2461    x =  PyInt_FromLong((long) AL_INPUT_RATE);
     2462    if (x == NULL || PyDict_SetItemString(d, "INPUT_RATE", x) < 0)
     2463        goto error;
     2464    Py_DECREF(x);
    24652465#endif
    24662466#ifdef AL_INPUT_SOURCE
    2467         x =  PyInt_FromLong((long) AL_INPUT_SOURCE);
    2468         if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
    2469                 goto error;
    2470         Py_DECREF(x);
     2467    x =  PyInt_FromLong((long) AL_INPUT_SOURCE);
     2468    if (x == NULL || PyDict_SetItemString(d, "INPUT_SOURCE", x) < 0)
     2469        goto error;
     2470    Py_DECREF(x);
    24712471#endif
    24722472#ifdef AL_INT32_ELEM
    2473         x =  PyInt_FromLong((long) AL_INT32_ELEM);
    2474         if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
    2475                 goto error;
    2476         Py_DECREF(x);
     2473    x =  PyInt_FromLong((long) AL_INT32_ELEM);
     2474    if (x == NULL || PyDict_SetItemString(d, "INT32_ELEM", x) < 0)
     2475        goto error;
     2476    Py_DECREF(x);
    24772477#endif
    24782478#ifdef AL_INT64_ELEM
    2479         x =  PyInt_FromLong((long) AL_INT64_ELEM);
    2480         if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
    2481                 goto error;
    2482         Py_DECREF(x);
     2479    x =  PyInt_FromLong((long) AL_INT64_ELEM);
     2480    if (x == NULL || PyDict_SetItemString(d, "INT64_ELEM", x) < 0)
     2481        goto error;
     2482    Py_DECREF(x);
    24832483#endif
    24842484#ifdef AL_INTERFACE
    2485         x =  PyInt_FromLong((long) AL_INTERFACE);
    2486         if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
    2487                 goto error;
    2488         Py_DECREF(x);
     2485    x =  PyInt_FromLong((long) AL_INTERFACE);
     2486    if (x == NULL || PyDict_SetItemString(d, "INTERFACE", x) < 0)
     2487        goto error;
     2488    Py_DECREF(x);
    24892489#endif
    24902490#ifdef AL_INTERFACE_TYPE
    2491         x =  PyInt_FromLong((long) AL_INTERFACE_TYPE);
    2492         if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
    2493                 goto error;
    2494         Py_DECREF(x);
     2491    x =  PyInt_FromLong((long) AL_INTERFACE_TYPE);
     2492    if (x == NULL || PyDict_SetItemString(d, "INTERFACE_TYPE", x) < 0)
     2493        goto error;
     2494    Py_DECREF(x);
    24952495#endif
    24962496#ifdef AL_INVALID_PARAM
    2497         x =  PyInt_FromLong((long) AL_INVALID_PARAM);
    2498         if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
    2499                 goto error;
    2500         Py_DECREF(x);
     2497    x =  PyInt_FromLong((long) AL_INVALID_PARAM);
     2498    if (x == NULL || PyDict_SetItemString(d, "INVALID_PARAM", x) < 0)
     2499        goto error;
     2500    Py_DECREF(x);
    25012501#endif
    25022502#ifdef AL_INVALID_VALUE
    2503         x =  PyInt_FromLong((long) AL_INVALID_VALUE);
    2504         if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
    2505                 goto error;
    2506         Py_DECREF(x);
     2503    x =  PyInt_FromLong((long) AL_INVALID_VALUE);
     2504    if (x == NULL || PyDict_SetItemString(d, "INVALID_VALUE", x) < 0)
     2505        goto error;
     2506    Py_DECREF(x);
    25072507#endif
    25082508#ifdef AL_JITTER
    2509         x =  PyInt_FromLong((long) AL_JITTER);
    2510         if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
    2511                 goto error;
    2512         Py_DECREF(x);
     2509    x =  PyInt_FromLong((long) AL_JITTER);
     2510    if (x == NULL || PyDict_SetItemString(d, "JITTER", x) < 0)
     2511        goto error;
     2512    Py_DECREF(x);
    25132513#endif
    25142514#ifdef AL_LABEL
    2515         x =  PyInt_FromLong((long) AL_LABEL);
    2516         if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
    2517                 goto error;
    2518         Py_DECREF(x);
     2515    x =  PyInt_FromLong((long) AL_LABEL);
     2516    if (x == NULL || PyDict_SetItemString(d, "LABEL", x) < 0)
     2517        goto error;
     2518    Py_DECREF(x);
    25192519#endif
    25202520#ifdef AL_LEFT_INPUT_ATTEN
    2521         x =  PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
    2522         if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
    2523                 goto error;
    2524         Py_DECREF(x);
     2521    x =  PyInt_FromLong((long) AL_LEFT_INPUT_ATTEN);
     2522    if (x == NULL || PyDict_SetItemString(d, "LEFT_INPUT_ATTEN", x) < 0)
     2523        goto error;
     2524    Py_DECREF(x);
    25252525#endif
    25262526#ifdef AL_LEFT_MONITOR_ATTEN
    2527         x =  PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
    2528         if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
    2529                 goto error;
    2530         Py_DECREF(x);
     2527    x =  PyInt_FromLong((long) AL_LEFT_MONITOR_ATTEN);
     2528    if (x == NULL || PyDict_SetItemString(d, "LEFT_MONITOR_ATTEN", x) < 0)
     2529        goto error;
     2530    Py_DECREF(x);
    25312531#endif
    25322532#ifdef AL_LEFT_SPEAKER_GAIN
    2533         x =  PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
    2534         if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
    2535                 goto error;
    2536         Py_DECREF(x);
     2533    x =  PyInt_FromLong((long) AL_LEFT_SPEAKER_GAIN);
     2534    if (x == NULL || PyDict_SetItemString(d, "LEFT_SPEAKER_GAIN", x) < 0)
     2535        goto error;
     2536    Py_DECREF(x);
    25372537#endif
    25382538#ifdef AL_LEFT1_INPUT_ATTEN
    2539         x =  PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
    2540         if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
    2541                 goto error;
    2542         Py_DECREF(x);
     2539    x =  PyInt_FromLong((long) AL_LEFT1_INPUT_ATTEN);
     2540    if (x == NULL || PyDict_SetItemString(d, "LEFT1_INPUT_ATTEN", x) < 0)
     2541        goto error;
     2542    Py_DECREF(x);
    25432543#endif
    25442544#ifdef AL_LEFT2_INPUT_ATTEN
    2545         x =  PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
    2546         if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
    2547                 goto error;
    2548         Py_DECREF(x);
     2545    x =  PyInt_FromLong((long) AL_LEFT2_INPUT_ATTEN);
     2546    if (x == NULL || PyDict_SetItemString(d, "LEFT2_INPUT_ATTEN", x) < 0)
     2547        goto error;
     2548    Py_DECREF(x);
    25492549#endif
    25502550#ifdef AL_LINE_IF_TYPE
    2551         x =  PyInt_FromLong((long) AL_LINE_IF_TYPE);
    2552         if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
    2553                 goto error;
    2554         Py_DECREF(x);
     2551    x =  PyInt_FromLong((long) AL_LINE_IF_TYPE);
     2552    if (x == NULL || PyDict_SetItemString(d, "LINE_IF_TYPE", x) < 0)
     2553        goto error;
     2554    Py_DECREF(x);
    25552555#endif
    25562556#ifdef AL_LOCKED
    2557         x =  PyInt_FromLong((long) AL_LOCKED);
    2558         if (x == NULL || PyDict_SetItemString(d, "LOCKED", x) < 0)
    2559                 goto error;
    2560         Py_DECREF(x);
     2557    x =  PyInt_FromLong((long) AL_LOCKED);
     2558    if (x == NULL || PyDict_SetItemString(d, "LOCKED", x) < 0)
     2559        goto error;
     2560    Py_DECREF(x);
    25612561#endif
    25622562#ifdef AL_MASTER_CLOCK
    2563         x =  PyInt_FromLong((long) AL_MASTER_CLOCK);
    2564         if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
    2565                 goto error;
    2566         Py_DECREF(x);
     2563    x =  PyInt_FromLong((long) AL_MASTER_CLOCK);
     2564    if (x == NULL || PyDict_SetItemString(d, "MASTER_CLOCK", x) < 0)
     2565        goto error;
     2566    Py_DECREF(x);
    25672567#endif
    25682568#ifdef AL_MATRIX_VAL
    2569         x =  PyInt_FromLong((long) AL_MATRIX_VAL);
    2570         if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
    2571                 goto error;
    2572         Py_DECREF(x);
     2569    x =  PyInt_FromLong((long) AL_MATRIX_VAL);
     2570    if (x == NULL || PyDict_SetItemString(d, "MATRIX_VAL", x) < 0)
     2571        goto error;
     2572    Py_DECREF(x);
    25732573#endif
    25742574#ifdef AL_MAX_ERROR
    2575         x =  PyInt_FromLong((long) AL_MAX_ERROR);
    2576         if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
    2577                 goto error;
    2578         Py_DECREF(x);
     2575    x =  PyInt_FromLong((long) AL_MAX_ERROR);
     2576    if (x == NULL || PyDict_SetItemString(d, "MAX_ERROR", x) < 0)
     2577        goto error;
     2578    Py_DECREF(x);
    25792579#endif
    25802580#ifdef AL_MAX_EVENT_PARAM
    2581         x =  PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
    2582         if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
    2583                 goto error;
    2584         Py_DECREF(x);
     2581    x =  PyInt_FromLong((long) AL_MAX_EVENT_PARAM);
     2582    if (x == NULL || PyDict_SetItemString(d, "MAX_EVENT_PARAM", x) < 0)
     2583        goto error;
     2584    Py_DECREF(x);
    25852585#endif
    25862586#ifdef AL_MAX_PBUFSIZE
    2587         x =  PyInt_FromLong((long) AL_MAX_PBUFSIZE);
    2588         if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
    2589                 goto error;
    2590         Py_DECREF(x);
     2587    x =  PyInt_FromLong((long) AL_MAX_PBUFSIZE);
     2588    if (x == NULL || PyDict_SetItemString(d, "MAX_PBUFSIZE", x) < 0)
     2589        goto error;
     2590    Py_DECREF(x);
    25912591#endif
    25922592#ifdef AL_MAX_PORTS
    2593         x =  PyInt_FromLong((long) AL_MAX_PORTS);
    2594         if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
    2595                 goto error;
    2596         Py_DECREF(x);
     2593    x =  PyInt_FromLong((long) AL_MAX_PORTS);
     2594    if (x == NULL || PyDict_SetItemString(d, "MAX_PORTS", x) < 0)
     2595        goto error;
     2596    Py_DECREF(x);
    25972597#endif
    25982598#ifdef AL_MAX_RESOURCE_ID
    2599         x =  PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
    2600         if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
    2601                 goto error;
    2602         Py_DECREF(x);
     2599    x =  PyInt_FromLong((long) AL_MAX_RESOURCE_ID);
     2600    if (x == NULL || PyDict_SetItemString(d, "MAX_RESOURCE_ID", x) < 0)
     2601        goto error;
     2602    Py_DECREF(x);
    26032603#endif
    26042604#ifdef AL_MAX_SETSIZE
    2605         x =  PyInt_FromLong((long) AL_MAX_SETSIZE);
    2606         if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
    2607                 goto error;
    2608         Py_DECREF(x);
     2605    x =  PyInt_FromLong((long) AL_MAX_SETSIZE);
     2606    if (x == NULL || PyDict_SetItemString(d, "MAX_SETSIZE", x) < 0)
     2607        goto error;
     2608    Py_DECREF(x);
    26092609#endif
    26102610#ifdef AL_MAX_STRLEN
    2611         x =  PyInt_FromLong((long) AL_MAX_STRLEN);
    2612         if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
    2613                 goto error;
    2614         Py_DECREF(x);
     2611    x =  PyInt_FromLong((long) AL_MAX_STRLEN);
     2612    if (x == NULL || PyDict_SetItemString(d, "MAX_STRLEN", x) < 0)
     2613        goto error;
     2614    Py_DECREF(x);
    26152615#endif
    26162616#ifdef AL_MCLK_TYPE
    2617         x =  PyInt_FromLong((long) AL_MCLK_TYPE);
    2618         if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
    2619                 goto error;
    2620         Py_DECREF(x);
     2617    x =  PyInt_FromLong((long) AL_MCLK_TYPE);
     2618    if (x == NULL || PyDict_SetItemString(d, "MCLK_TYPE", x) < 0)
     2619        goto error;
     2620    Py_DECREF(x);
    26212621#endif
    26222622#ifdef AL_MIC_IF_TYPE
    2623         x =  PyInt_FromLong((long) AL_MIC_IF_TYPE);
    2624         if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
    2625                 goto error;
    2626         Py_DECREF(x);
     2623    x =  PyInt_FromLong((long) AL_MIC_IF_TYPE);
     2624    if (x == NULL || PyDict_SetItemString(d, "MIC_IF_TYPE", x) < 0)
     2625        goto error;
     2626    Py_DECREF(x);
    26272627#endif
    26282628#ifdef AL_MONITOR_CTL
    2629         x =  PyInt_FromLong((long) AL_MONITOR_CTL);
    2630         if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
    2631                 goto error;
    2632         Py_DECREF(x);
     2629    x =  PyInt_FromLong((long) AL_MONITOR_CTL);
     2630    if (x == NULL || PyDict_SetItemString(d, "MONITOR_CTL", x) < 0)
     2631        goto error;
     2632    Py_DECREF(x);
    26332633#endif
    26342634#ifdef AL_MONITOR_OFF
    2635         x =  PyInt_FromLong((long) AL_MONITOR_OFF);
    2636         if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
    2637                 goto error;
    2638         Py_DECREF(x);
     2635    x =  PyInt_FromLong((long) AL_MONITOR_OFF);
     2636    if (x == NULL || PyDict_SetItemString(d, "MONITOR_OFF", x) < 0)
     2637        goto error;
     2638    Py_DECREF(x);
    26392639#endif
    26402640#ifdef AL_MONITOR_ON
    2641         x =  PyInt_FromLong((long) AL_MONITOR_ON);
    2642         if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
    2643                 goto error;
    2644         Py_DECREF(x);
     2641    x =  PyInt_FromLong((long) AL_MONITOR_ON);
     2642    if (x == NULL || PyDict_SetItemString(d, "MONITOR_ON", x) < 0)
     2643        goto error;
     2644    Py_DECREF(x);
    26452645#endif
    26462646#ifdef AL_MONO
    2647         x =  PyInt_FromLong((long) AL_MONO);
    2648         if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
    2649                 goto error;
    2650         Py_DECREF(x);
     2647    x =  PyInt_FromLong((long) AL_MONO);
     2648    if (x == NULL || PyDict_SetItemString(d, "MONO", x) < 0)
     2649        goto error;
     2650    Py_DECREF(x);
    26512651#endif
    26522652#ifdef AL_MUTE
    2653         x =  PyInt_FromLong((long) AL_MUTE);
    2654         if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
    2655                 goto error;
    2656         Py_DECREF(x);
     2653    x =  PyInt_FromLong((long) AL_MUTE);
     2654    if (x == NULL || PyDict_SetItemString(d, "MUTE", x) < 0)
     2655        goto error;
     2656    Py_DECREF(x);
    26572657#endif
    26582658#ifdef AL_NAME
    2659         x =  PyInt_FromLong((long) AL_NAME);
    2660         if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
    2661                 goto error;
    2662         Py_DECREF(x);
     2659    x =  PyInt_FromLong((long) AL_NAME);
     2660    if (x == NULL || PyDict_SetItemString(d, "NAME", x) < 0)
     2661        goto error;
     2662    Py_DECREF(x);
    26632663#endif
    26642664#ifdef AL_NEG_INFINITY
    2665         x =  PyInt_FromLong((long) AL_NEG_INFINITY);
    2666         if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
    2667                 goto error;
    2668         Py_DECREF(x);
     2665    x =  PyInt_FromLong((long) AL_NEG_INFINITY);
     2666    if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY", x) < 0)
     2667        goto error;
     2668    Py_DECREF(x);
    26692669#endif
    26702670#ifdef AL_NEG_INFINITY_BIT
    2671         x =  PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
    2672         if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
    2673                 goto error;
    2674         Py_DECREF(x);
     2671    x =  PyInt_FromLong((long) AL_NEG_INFINITY_BIT);
     2672    if (x == NULL || PyDict_SetItemString(d, "NEG_INFINITY_BIT", x) < 0)
     2673        goto error;
     2674    Py_DECREF(x);
    26752675#endif
    26762676#ifdef AL_NO_CHANGE
    2677         x =  PyInt_FromLong((long) AL_NO_CHANGE);
    2678         if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
    2679                 goto error;
    2680         Py_DECREF(x);
     2677    x =  PyInt_FromLong((long) AL_NO_CHANGE);
     2678    if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE", x) < 0)
     2679        goto error;
     2680    Py_DECREF(x);
    26812681#endif
    26822682#ifdef AL_NO_CHANGE_BIT
    2683         x =  PyInt_FromLong((long) AL_NO_CHANGE_BIT);
    2684         if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
    2685                 goto error;
    2686         Py_DECREF(x);
     2683    x =  PyInt_FromLong((long) AL_NO_CHANGE_BIT);
     2684    if (x == NULL || PyDict_SetItemString(d, "NO_CHANGE_BIT", x) < 0)
     2685        goto error;
     2686    Py_DECREF(x);
    26872687#endif
    26882688#ifdef AL_NO_ELEM
    2689         x =  PyInt_FromLong((long) AL_NO_ELEM);
    2690         if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
    2691                 goto error;
    2692         Py_DECREF(x);
     2689    x =  PyInt_FromLong((long) AL_NO_ELEM);
     2690    if (x == NULL || PyDict_SetItemString(d, "NO_ELEM", x) < 0)
     2691        goto error;
     2692    Py_DECREF(x);
    26932693#endif
    26942694#ifdef AL_NO_ERRORS
    2695         x =  PyInt_FromLong((long) AL_NO_ERRORS);
    2696         if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
    2697                 goto error;
    2698         Py_DECREF(x);
     2695    x =  PyInt_FromLong((long) AL_NO_ERRORS);
     2696    if (x == NULL || PyDict_SetItemString(d, "NO_ERRORS", x) < 0)
     2697        goto error;
     2698    Py_DECREF(x);
    26992699#endif
    27002700#ifdef AL_NO_OP
    2701         x =  PyInt_FromLong((long) AL_NO_OP);
    2702         if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
    2703                 goto error;
    2704         Py_DECREF(x);
     2701    x =  PyInt_FromLong((long) AL_NO_OP);
     2702    if (x == NULL || PyDict_SetItemString(d, "NO_OP", x) < 0)
     2703        goto error;
     2704    Py_DECREF(x);
    27052705#endif
    27062706#ifdef AL_NO_VAL
    2707         x =  PyInt_FromLong((long) AL_NO_VAL);
    2708         if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
    2709                 goto error;
    2710         Py_DECREF(x);
     2707    x =  PyInt_FromLong((long) AL_NO_VAL);
     2708    if (x == NULL || PyDict_SetItemString(d, "NO_VAL", x) < 0)
     2709        goto error;
     2710    Py_DECREF(x);
    27112711#endif
    27122712#ifdef AL_NULL_INTERFACE
    2713         x =  PyInt_FromLong((long) AL_NULL_INTERFACE);
    2714         if (x == NULL || PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
    2715                 goto error;
    2716         Py_DECREF(x);
     2713    x =  PyInt_FromLong((long) AL_NULL_INTERFACE);
     2714    if (x == NULL || PyDict_SetItemString(d, "NULL_INTERFACE", x) < 0)
     2715        goto error;
     2716    Py_DECREF(x);
    27172717#endif
    27182718#ifdef AL_NULL_RESOURCE
    2719         x =  PyInt_FromLong((long) AL_NULL_RESOURCE);
    2720         if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
    2721                 goto error;
    2722         Py_DECREF(x);
     2719    x =  PyInt_FromLong((long) AL_NULL_RESOURCE);
     2720    if (x == NULL || PyDict_SetItemString(d, "NULL_RESOURCE", x) < 0)
     2721        goto error;
     2722    Py_DECREF(x);
    27232723#endif
    27242724#ifdef AL_OPTICAL_IF_TYPE
    2725         x =  PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
    2726         if (x == NULL || PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
    2727                 goto error;
    2728         Py_DECREF(x);
     2725    x =  PyInt_FromLong((long) AL_OPTICAL_IF_TYPE);
     2726    if (x == NULL || PyDict_SetItemString(d, "OPTICAL_IF_TYPE", x) < 0)
     2727        goto error;
     2728    Py_DECREF(x);
    27292729#endif
    27302730#ifdef AL_OUTPUT_COUNT
    2731         x =  PyInt_FromLong((long) AL_OUTPUT_COUNT);
    2732         if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
    2733                 goto error;
    2734         Py_DECREF(x);
     2731    x =  PyInt_FromLong((long) AL_OUTPUT_COUNT);
     2732    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_COUNT", x) < 0)
     2733        goto error;
     2734    Py_DECREF(x);
    27352735#endif
    27362736#ifdef AL_OUTPUT_DEVICE_TYPE
    2737         x =  PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
    2738         if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
    2739                 goto error;
    2740         Py_DECREF(x);
     2737    x =  PyInt_FromLong((long) AL_OUTPUT_DEVICE_TYPE);
     2738    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_DEVICE_TYPE", x) < 0)
     2739        goto error;
     2740    Py_DECREF(x);
    27412741#endif
    27422742#ifdef AL_OUTPUT_HRB_TYPE
    2743         x =  PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
    2744         if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
    2745                 goto error;
    2746         Py_DECREF(x);
     2743    x =  PyInt_FromLong((long) AL_OUTPUT_HRB_TYPE);
     2744    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_HRB_TYPE", x) < 0)
     2745        goto error;
     2746    Py_DECREF(x);
    27472747#endif
    27482748#ifdef AL_OUTPUT_PORT_TYPE
    2749         x =  PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
    2750         if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
    2751                 goto error;
    2752         Py_DECREF(x);
     2749    x =  PyInt_FromLong((long) AL_OUTPUT_PORT_TYPE);
     2750    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_PORT_TYPE", x) < 0)
     2751        goto error;
     2752    Py_DECREF(x);
    27532753#endif
    27542754#ifdef AL_OUTPUT_RATE
    2755         x =  PyInt_FromLong((long) AL_OUTPUT_RATE);
    2756         if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
    2757                 goto error;
    2758         Py_DECREF(x);
     2755    x =  PyInt_FromLong((long) AL_OUTPUT_RATE);
     2756    if (x == NULL || PyDict_SetItemString(d, "OUTPUT_RATE", x) < 0)
     2757        goto error;
     2758    Py_DECREF(x);
    27592759#endif
    27602760#ifdef AL_PARAM_BIT
    2761         x =  PyInt_FromLong((long) AL_PARAM_BIT);
    2762         if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
    2763                 goto error;
    2764         Py_DECREF(x);
     2761    x =  PyInt_FromLong((long) AL_PARAM_BIT);
     2762    if (x == NULL || PyDict_SetItemString(d, "PARAM_BIT", x) < 0)
     2763        goto error;
     2764    Py_DECREF(x);
    27652765#endif
    27662766#ifdef AL_PARAMS
    2767         x =  PyInt_FromLong((long) AL_PARAMS);
    2768         if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
    2769                 goto error;
    2770         Py_DECREF(x);
     2767    x =  PyInt_FromLong((long) AL_PARAMS);
     2768    if (x == NULL || PyDict_SetItemString(d, "PARAMS", x) < 0)
     2769        goto error;
     2770    Py_DECREF(x);
    27712771#endif
    27722772#ifdef AL_PORT_COUNT
    2773         x =  PyInt_FromLong((long) AL_PORT_COUNT);
    2774         if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
    2775                 goto error;
    2776         Py_DECREF(x);
     2773    x =  PyInt_FromLong((long) AL_PORT_COUNT);
     2774    if (x == NULL || PyDict_SetItemString(d, "PORT_COUNT", x) < 0)
     2775        goto error;
     2776    Py_DECREF(x);
    27772777#endif
    27782778#ifdef AL_PORT_TYPE
    2779         x =  PyInt_FromLong((long) AL_PORT_TYPE);
    2780         if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
    2781                 goto error;
    2782         Py_DECREF(x);
     2779    x =  PyInt_FromLong((long) AL_PORT_TYPE);
     2780    if (x == NULL || PyDict_SetItemString(d, "PORT_TYPE", x) < 0)
     2781        goto error;
     2782    Py_DECREF(x);
    27832783#endif
    27842784#ifdef AL_PORTS
    2785         x =  PyInt_FromLong((long) AL_PORTS);
    2786         if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
    2787                 goto error;
    2788         Py_DECREF(x);
     2785    x =  PyInt_FromLong((long) AL_PORTS);
     2786    if (x == NULL || PyDict_SetItemString(d, "PORTS", x) < 0)
     2787        goto error;
     2788    Py_DECREF(x);
    27892789#endif
    27902790#ifdef AL_PORTSTYLE_DIRECT
    2791         x =  PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
    2792         if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
    2793                 goto error;
    2794         Py_DECREF(x);
     2791    x =  PyInt_FromLong((long) AL_PORTSTYLE_DIRECT);
     2792    if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_DIRECT", x) < 0)
     2793        goto error;
     2794    Py_DECREF(x);
    27952795#endif
    27962796#ifdef AL_PORTSTYLE_SERIAL
    2797         x =  PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
    2798         if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
    2799                 goto error;
    2800         Py_DECREF(x);
     2797    x =  PyInt_FromLong((long) AL_PORTSTYLE_SERIAL);
     2798    if (x == NULL || PyDict_SetItemString(d, "PORTSTYLE_SERIAL", x) < 0)
     2799        goto error;
     2800    Py_DECREF(x);
    28012801#endif
    28022802#ifdef AL_PRINT_ERRORS
    2803         x =  PyInt_FromLong((long) AL_PRINT_ERRORS);
    2804         if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
    2805                 goto error;
    2806         Py_DECREF(x);
     2803    x =  PyInt_FromLong((long) AL_PRINT_ERRORS);
     2804    if (x == NULL || PyDict_SetItemString(d, "PRINT_ERRORS", x) < 0)
     2805        goto error;
     2806    Py_DECREF(x);
    28072807#endif
    28082808#ifdef AL_PTR_ELEM
    2809         x =  PyInt_FromLong((long) AL_PTR_ELEM);
    2810         if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
    2811                 goto error;
    2812         Py_DECREF(x);
     2809    x =  PyInt_FromLong((long) AL_PTR_ELEM);
     2810    if (x == NULL || PyDict_SetItemString(d, "PTR_ELEM", x) < 0)
     2811        goto error;
     2812    Py_DECREF(x);
    28132813#endif
    28142814#ifdef AL_RANGE_VALUE
    2815         x =  PyInt_FromLong((long) AL_RANGE_VALUE);
    2816         if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
    2817                 goto error;
    2818         Py_DECREF(x);
     2815    x =  PyInt_FromLong((long) AL_RANGE_VALUE);
     2816    if (x == NULL || PyDict_SetItemString(d, "RANGE_VALUE", x) < 0)
     2817        goto error;
     2818    Py_DECREF(x);
    28192819#endif
    28202820#ifdef AL_RATE
    2821         x =  PyInt_FromLong((long) AL_RATE);
    2822         if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
    2823                 goto error;
    2824         Py_DECREF(x);
     2821    x =  PyInt_FromLong((long) AL_RATE);
     2822    if (x == NULL || PyDict_SetItemString(d, "RATE", x) < 0)
     2823        goto error;
     2824    Py_DECREF(x);
    28252825#endif
    28262826#ifdef AL_RATE_11025
    2827         x =  PyInt_FromLong((long) AL_RATE_11025);
    2828         if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
    2829                 goto error;
    2830         Py_DECREF(x);
     2827    x =  PyInt_FromLong((long) AL_RATE_11025);
     2828    if (x == NULL || PyDict_SetItemString(d, "RATE_11025", x) < 0)
     2829        goto error;
     2830    Py_DECREF(x);
    28312831#endif
    28322832#ifdef AL_RATE_16000
    2833         x =  PyInt_FromLong((long) AL_RATE_16000);
    2834         if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
    2835                 goto error;
    2836         Py_DECREF(x);
     2833    x =  PyInt_FromLong((long) AL_RATE_16000);
     2834    if (x == NULL || PyDict_SetItemString(d, "RATE_16000", x) < 0)
     2835        goto error;
     2836    Py_DECREF(x);
    28372837#endif
    28382838#ifdef AL_RATE_22050
    2839         x =  PyInt_FromLong((long) AL_RATE_22050);
    2840         if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
    2841                 goto error;
    2842         Py_DECREF(x);
     2839    x =  PyInt_FromLong((long) AL_RATE_22050);
     2840    if (x == NULL || PyDict_SetItemString(d, "RATE_22050", x) < 0)
     2841        goto error;
     2842    Py_DECREF(x);
    28432843#endif
    28442844#ifdef AL_RATE_32000
    2845         x =  PyInt_FromLong((long) AL_RATE_32000);
    2846         if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
    2847                 goto error;
    2848         Py_DECREF(x);
     2845    x =  PyInt_FromLong((long) AL_RATE_32000);
     2846    if (x == NULL || PyDict_SetItemString(d, "RATE_32000", x) < 0)
     2847        goto error;
     2848    Py_DECREF(x);
    28492849#endif
    28502850#ifdef AL_RATE_44100
    2851         x =  PyInt_FromLong((long) AL_RATE_44100);
    2852         if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
    2853                 goto error;
    2854         Py_DECREF(x);
     2851    x =  PyInt_FromLong((long) AL_RATE_44100);
     2852    if (x == NULL || PyDict_SetItemString(d, "RATE_44100", x) < 0)
     2853        goto error;
     2854    Py_DECREF(x);
    28552855#endif
    28562856#ifdef AL_RATE_48000
    2857         x =  PyInt_FromLong((long) AL_RATE_48000);
    2858         if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
    2859                 goto error;
    2860         Py_DECREF(x);
     2857    x =  PyInt_FromLong((long) AL_RATE_48000);
     2858    if (x == NULL || PyDict_SetItemString(d, "RATE_48000", x) < 0)
     2859        goto error;
     2860    Py_DECREF(x);
    28612861#endif
    28622862#ifdef AL_RATE_8000
    2863         x =  PyInt_FromLong((long) AL_RATE_8000);
    2864         if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
    2865                 goto error;
    2866         Py_DECREF(x);
     2863    x =  PyInt_FromLong((long) AL_RATE_8000);
     2864    if (x == NULL || PyDict_SetItemString(d, "RATE_8000", x) < 0)
     2865        goto error;
     2866    Py_DECREF(x);
    28672867#endif
    28682868#ifdef AL_RATE_AES_1
    2869         x =  PyInt_FromLong((long) AL_RATE_AES_1);
    2870         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
    2871                 goto error;
    2872         Py_DECREF(x);
     2869    x =  PyInt_FromLong((long) AL_RATE_AES_1);
     2870    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1", x) < 0)
     2871        goto error;
     2872    Py_DECREF(x);
    28732873#endif
    28742874#ifdef AL_RATE_AES_1s
    2875         x =  PyInt_FromLong((long) AL_RATE_AES_1s);
    2876         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
    2877                 goto error;
    2878         Py_DECREF(x);
     2875    x =  PyInt_FromLong((long) AL_RATE_AES_1s);
     2876    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_1s", x) < 0)
     2877        goto error;
     2878    Py_DECREF(x);
    28792879#endif
    28802880#ifdef AL_RATE_AES_2
    2881         x =  PyInt_FromLong((long) AL_RATE_AES_2);
    2882         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
    2883                 goto error;
    2884         Py_DECREF(x);
     2881    x =  PyInt_FromLong((long) AL_RATE_AES_2);
     2882    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_2", x) < 0)
     2883        goto error;
     2884    Py_DECREF(x);
    28852885#endif
    28862886#ifdef AL_RATE_AES_3
    2887         x =  PyInt_FromLong((long) AL_RATE_AES_3);
    2888         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
    2889                 goto error;
    2890         Py_DECREF(x);
     2887    x =  PyInt_FromLong((long) AL_RATE_AES_3);
     2888    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_3", x) < 0)
     2889        goto error;
     2890    Py_DECREF(x);
    28912891#endif
    28922892#ifdef AL_RATE_AES_4
    2893         x =  PyInt_FromLong((long) AL_RATE_AES_4);
    2894         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
    2895                 goto error;
    2896         Py_DECREF(x);
     2893    x =  PyInt_FromLong((long) AL_RATE_AES_4);
     2894    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_4", x) < 0)
     2895        goto error;
     2896    Py_DECREF(x);
    28972897#endif
    28982898#ifdef AL_RATE_AES_6
    2899         x =  PyInt_FromLong((long) AL_RATE_AES_6);
    2900         if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
    2901                 goto error;
    2902         Py_DECREF(x);
     2899    x =  PyInt_FromLong((long) AL_RATE_AES_6);
     2900    if (x == NULL || PyDict_SetItemString(d, "RATE_AES_6", x) < 0)
     2901        goto error;
     2902    Py_DECREF(x);
    29032903#endif
    29042904#ifdef AL_RATE_FRACTION_D
    2905         x =  PyInt_FromLong((long) AL_RATE_FRACTION_D);
    2906         if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
    2907                 goto error;
    2908         Py_DECREF(x);
     2905    x =  PyInt_FromLong((long) AL_RATE_FRACTION_D);
     2906    if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_D", x) < 0)
     2907        goto error;
     2908    Py_DECREF(x);
    29092909#endif
    29102910#ifdef AL_RATE_FRACTION_N
    2911         x =  PyInt_FromLong((long) AL_RATE_FRACTION_N);
    2912         if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
    2913                 goto error;
    2914         Py_DECREF(x);
     2911    x =  PyInt_FromLong((long) AL_RATE_FRACTION_N);
     2912    if (x == NULL || PyDict_SetItemString(d, "RATE_FRACTION_N", x) < 0)
     2913        goto error;
     2914    Py_DECREF(x);
    29152915#endif
    29162916#ifdef AL_RATE_INPUTRATE
    2917         x =  PyInt_FromLong((long) AL_RATE_INPUTRATE);
    2918         if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
    2919                 goto error;
    2920         Py_DECREF(x);
     2917    x =  PyInt_FromLong((long) AL_RATE_INPUTRATE);
     2918    if (x == NULL || PyDict_SetItemString(d, "RATE_INPUTRATE", x) < 0)
     2919        goto error;
     2920    Py_DECREF(x);
    29212921#endif
    29222922#ifdef AL_RATE_NO_DIGITAL_INPUT
    2923         x =  PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
    2924         if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
    2925                 goto error;
    2926         Py_DECREF(x);
     2923    x =  PyInt_FromLong((long) AL_RATE_NO_DIGITAL_INPUT);
     2924    if (x == NULL || PyDict_SetItemString(d, "RATE_NO_DIGITAL_INPUT", x) < 0)
     2925        goto error;
     2926    Py_DECREF(x);
    29272927#endif
    29282928#ifdef AL_RATE_UNACQUIRED
    2929         x =  PyInt_FromLong((long) AL_RATE_UNACQUIRED);
    2930         if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
    2931                 goto error;
    2932         Py_DECREF(x);
     2929    x =  PyInt_FromLong((long) AL_RATE_UNACQUIRED);
     2930    if (x == NULL || PyDict_SetItemString(d, "RATE_UNACQUIRED", x) < 0)
     2931        goto error;
     2932    Py_DECREF(x);
    29332933#endif
    29342934#ifdef AL_RATE_UNDEFINED
    2935         x =  PyInt_FromLong((long) AL_RATE_UNDEFINED);
    2936         if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
    2937                 goto error;
    2938         Py_DECREF(x);
     2935    x =  PyInt_FromLong((long) AL_RATE_UNDEFINED);
     2936    if (x == NULL || PyDict_SetItemString(d, "RATE_UNDEFINED", x) < 0)
     2937        goto error;
     2938    Py_DECREF(x);
    29392939#endif
    29402940#ifdef AL_REF_0DBV
    2941         x =  PyInt_FromLong((long) AL_REF_0DBV);
    2942         if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
    2943                 goto error;
    2944         Py_DECREF(x);
     2941    x =  PyInt_FromLong((long) AL_REF_0DBV);
     2942    if (x == NULL || PyDict_SetItemString(d, "REF_0DBV", x) < 0)
     2943        goto error;
     2944    Py_DECREF(x);
    29452945#endif
    29462946#ifdef AL_REF_NONE
    2947         x =  PyInt_FromLong((long) AL_REF_NONE);
    2948         if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
    2949                 goto error;
    2950         Py_DECREF(x);
     2947    x =  PyInt_FromLong((long) AL_REF_NONE);
     2948    if (x == NULL || PyDict_SetItemString(d, "REF_NONE", x) < 0)
     2949        goto error;
     2950    Py_DECREF(x);
    29512951#endif
    29522952#ifdef AL_RESERVED1_TYPE
    2953         x =  PyInt_FromLong((long) AL_RESERVED1_TYPE);
    2954         if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
    2955                 goto error;
    2956         Py_DECREF(x);
     2953    x =  PyInt_FromLong((long) AL_RESERVED1_TYPE);
     2954    if (x == NULL || PyDict_SetItemString(d, "RESERVED1_TYPE", x) < 0)
     2955        goto error;
     2956    Py_DECREF(x);
    29572957#endif
    29582958#ifdef AL_RESERVED2_TYPE
    2959         x =  PyInt_FromLong((long) AL_RESERVED2_TYPE);
    2960         if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
    2961                 goto error;
    2962         Py_DECREF(x);
     2959    x =  PyInt_FromLong((long) AL_RESERVED2_TYPE);
     2960    if (x == NULL || PyDict_SetItemString(d, "RESERVED2_TYPE", x) < 0)
     2961        goto error;
     2962    Py_DECREF(x);
    29632963#endif
    29642964#ifdef AL_RESERVED3_TYPE
    2965         x =  PyInt_FromLong((long) AL_RESERVED3_TYPE);
    2966         if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
    2967                 goto error;
    2968         Py_DECREF(x);
     2965    x =  PyInt_FromLong((long) AL_RESERVED3_TYPE);
     2966    if (x == NULL || PyDict_SetItemString(d, "RESERVED3_TYPE", x) < 0)
     2967        goto error;
     2968    Py_DECREF(x);
    29692969#endif
    29702970#ifdef AL_RESERVED4_TYPE
    2971         x =  PyInt_FromLong((long) AL_RESERVED4_TYPE);
    2972         if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
    2973                 goto error;
    2974         Py_DECREF(x);
     2971    x =  PyInt_FromLong((long) AL_RESERVED4_TYPE);
     2972    if (x == NULL || PyDict_SetItemString(d, "RESERVED4_TYPE", x) < 0)
     2973        goto error;
     2974    Py_DECREF(x);
    29752975#endif
    29762976#ifdef AL_RESOURCE
    2977         x =  PyInt_FromLong((long) AL_RESOURCE);
    2978         if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
    2979                 goto error;
    2980         Py_DECREF(x);
     2977    x =  PyInt_FromLong((long) AL_RESOURCE);
     2978    if (x == NULL || PyDict_SetItemString(d, "RESOURCE", x) < 0)
     2979        goto error;
     2980    Py_DECREF(x);
    29812981#endif
    29822982#ifdef AL_RESOURCE_ELEM
    2983         x =  PyInt_FromLong((long) AL_RESOURCE_ELEM);
    2984         if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
    2985                 goto error;
    2986         Py_DECREF(x);
     2983    x =  PyInt_FromLong((long) AL_RESOURCE_ELEM);
     2984    if (x == NULL || PyDict_SetItemString(d, "RESOURCE_ELEM", x) < 0)
     2985        goto error;
     2986    Py_DECREF(x);
    29872987#endif
    29882988#ifdef AL_RESOURCE_TYPE
    2989         x =  PyInt_FromLong((long) AL_RESOURCE_TYPE);
    2990         if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
    2991                 goto error;
    2992         Py_DECREF(x);
     2989    x =  PyInt_FromLong((long) AL_RESOURCE_TYPE);
     2990    if (x == NULL || PyDict_SetItemString(d, "RESOURCE_TYPE", x) < 0)
     2991        goto error;
     2992    Py_DECREF(x);
    29932993#endif
    29942994#ifdef AL_RIGHT_INPUT_ATTEN
    2995         x =  PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
    2996         if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
    2997                 goto error;
    2998         Py_DECREF(x);
     2995    x =  PyInt_FromLong((long) AL_RIGHT_INPUT_ATTEN);
     2996    if (x == NULL || PyDict_SetItemString(d, "RIGHT_INPUT_ATTEN", x) < 0)
     2997        goto error;
     2998    Py_DECREF(x);
    29992999#endif
    30003000#ifdef AL_RIGHT_MONITOR_ATTEN
    3001         x =  PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
    3002         if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
    3003                 goto error;
    3004         Py_DECREF(x);
     3001    x =  PyInt_FromLong((long) AL_RIGHT_MONITOR_ATTEN);
     3002    if (x == NULL || PyDict_SetItemString(d, "RIGHT_MONITOR_ATTEN", x) < 0)
     3003        goto error;
     3004    Py_DECREF(x);
    30053005#endif
    30063006#ifdef AL_RIGHT_SPEAKER_GAIN
    3007         x =  PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
    3008         if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
    3009                 goto error;
    3010         Py_DECREF(x);
     3007    x =  PyInt_FromLong((long) AL_RIGHT_SPEAKER_GAIN);
     3008    if (x == NULL || PyDict_SetItemString(d, "RIGHT_SPEAKER_GAIN", x) < 0)
     3009        goto error;
     3010    Py_DECREF(x);
    30113011#endif
    30123012#ifdef AL_RIGHT1_INPUT_ATTEN
    3013         x =  PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
    3014         if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
    3015                 goto error;
    3016         Py_DECREF(x);
     3013    x =  PyInt_FromLong((long) AL_RIGHT1_INPUT_ATTEN);
     3014    if (x == NULL || PyDict_SetItemString(d, "RIGHT1_INPUT_ATTEN", x) < 0)
     3015        goto error;
     3016    Py_DECREF(x);
    30173017#endif
    30183018#ifdef AL_RIGHT2_INPUT_ATTEN
    3019         x =  PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
    3020         if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
    3021                 goto error;
    3022         Py_DECREF(x);
     3019    x =  PyInt_FromLong((long) AL_RIGHT2_INPUT_ATTEN);
     3020    if (x == NULL || PyDict_SetItemString(d, "RIGHT2_INPUT_ATTEN", x) < 0)
     3021        goto error;
     3022    Py_DECREF(x);
    30233023#endif
    30243024#ifdef AL_SAMPFMT_DOUBLE
    3025         x =  PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
    3026         if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
    3027                 goto error;
    3028         Py_DECREF(x);
     3025    x =  PyInt_FromLong((long) AL_SAMPFMT_DOUBLE);
     3026    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_DOUBLE", x) < 0)
     3027        goto error;
     3028    Py_DECREF(x);
    30293029#endif
    30303030#ifdef AL_SAMPFMT_FLOAT
    3031         x =  PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
    3032         if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
    3033                 goto error;
    3034         Py_DECREF(x);
     3031    x =  PyInt_FromLong((long) AL_SAMPFMT_FLOAT);
     3032    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_FLOAT", x) < 0)
     3033        goto error;
     3034    Py_DECREF(x);
    30353035#endif
    30363036#ifdef AL_SAMPFMT_TWOSCOMP
    3037         x =  PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
    3038         if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
    3039                 goto error;
    3040         Py_DECREF(x);
     3037    x =  PyInt_FromLong((long) AL_SAMPFMT_TWOSCOMP);
     3038    if (x == NULL || PyDict_SetItemString(d, "SAMPFMT_TWOSCOMP", x) < 0)
     3039        goto error;
     3040    Py_DECREF(x);
    30413041#endif
    30423042#ifdef AL_SAMPLE_16
    3043         x =  PyInt_FromLong((long) AL_SAMPLE_16);
    3044         if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
    3045                 goto error;
    3046         Py_DECREF(x);
     3043    x =  PyInt_FromLong((long) AL_SAMPLE_16);
     3044    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_16", x) < 0)
     3045        goto error;
     3046    Py_DECREF(x);
    30473047#endif
    30483048#ifdef AL_SAMPLE_24
    3049         x =  PyInt_FromLong((long) AL_SAMPLE_24);
    3050         if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
    3051                 goto error;
    3052         Py_DECREF(x);
     3049    x =  PyInt_FromLong((long) AL_SAMPLE_24);
     3050    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_24", x) < 0)
     3051        goto error;
     3052    Py_DECREF(x);
    30533053#endif
    30543054#ifdef AL_SAMPLE_8
    3055         x =  PyInt_FromLong((long) AL_SAMPLE_8);
    3056         if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
    3057                 goto error;
    3058         Py_DECREF(x);
     3055    x =  PyInt_FromLong((long) AL_SAMPLE_8);
     3056    if (x == NULL || PyDict_SetItemString(d, "SAMPLE_8", x) < 0)
     3057        goto error;
     3058    Py_DECREF(x);
    30593059#endif
    30603060#ifdef AL_SCALAR_VAL
    3061         x =  PyInt_FromLong((long) AL_SCALAR_VAL);
    3062         if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
    3063                 goto error;
    3064         Py_DECREF(x);
     3061    x =  PyInt_FromLong((long) AL_SCALAR_VAL);
     3062    if (x == NULL || PyDict_SetItemString(d, "SCALAR_VAL", x) < 0)
     3063        goto error;
     3064    Py_DECREF(x);
    30653065#endif
    30663066#ifdef AL_SET_VAL
    3067         x =  PyInt_FromLong((long) AL_SET_VAL);
    3068         if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
    3069                 goto error;
    3070         Py_DECREF(x);
     3067    x =  PyInt_FromLong((long) AL_SET_VAL);
     3068    if (x == NULL || PyDict_SetItemString(d, "SET_VAL", x) < 0)
     3069        goto error;
     3070    Py_DECREF(x);
    30713071#endif
    30723072#ifdef AL_SHORT_NAME
    3073         x =  PyInt_FromLong((long) AL_SHORT_NAME);
    3074         if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
    3075                 goto error;
    3076         Py_DECREF(x);
     3073    x =  PyInt_FromLong((long) AL_SHORT_NAME);
     3074    if (x == NULL || PyDict_SetItemString(d, "SHORT_NAME", x) < 0)
     3075        goto error;
     3076    Py_DECREF(x);
    30773077#endif
    30783078#ifdef AL_SMPTE272M_IF_TYPE
    3079         x =  PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
    3080         if (x == NULL || PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
    3081                 goto error;
    3082         Py_DECREF(x);
     3079    x =  PyInt_FromLong((long) AL_SMPTE272M_IF_TYPE);
     3080    if (x == NULL || PyDict_SetItemString(d, "SMPTE272M_IF_TYPE", x) < 0)
     3081        goto error;
     3082    Py_DECREF(x);
    30833083#endif
    30843084#ifdef AL_SOURCE
    3085         x =  PyInt_FromLong((long) AL_SOURCE);
    3086         if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
    3087                 goto error;
    3088         Py_DECREF(x);
     3085    x =  PyInt_FromLong((long) AL_SOURCE);
     3086    if (x == NULL || PyDict_SetItemString(d, "SOURCE", x) < 0)
     3087        goto error;
     3088    Py_DECREF(x);
    30893089#endif
    30903090#ifdef AL_SPEAKER_IF_TYPE
    3091         x =  PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
    3092         if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
    3093                 goto error;
    3094         Py_DECREF(x);
     3091    x =  PyInt_FromLong((long) AL_SPEAKER_IF_TYPE);
     3092    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_IF_TYPE", x) < 0)
     3093        goto error;
     3094    Py_DECREF(x);
    30953095#endif
    30963096#ifdef AL_SPEAKER_MUTE_CTL
    3097         x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
    3098         if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
    3099                 goto error;
    3100         Py_DECREF(x);
     3097    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_CTL);
     3098    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_CTL", x) < 0)
     3099        goto error;
     3100    Py_DECREF(x);
    31013101#endif
    31023102#ifdef AL_SPEAKER_MUTE_OFF
    3103         x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
    3104         if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
    3105                 goto error;
    3106         Py_DECREF(x);
     3103    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_OFF);
     3104    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_OFF", x) < 0)
     3105        goto error;
     3106    Py_DECREF(x);
    31073107#endif
    31083108#ifdef AL_SPEAKER_MUTE_ON
    3109         x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
    3110         if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
    3111                 goto error;
    3112         Py_DECREF(x);
     3109    x =  PyInt_FromLong((long) AL_SPEAKER_MUTE_ON);
     3110    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_MUTE_ON", x) < 0)
     3111        goto error;
     3112    Py_DECREF(x);
    31133113#endif
    31143114#ifdef AL_SPEAKER_PLUS_LINE_IF_TYPE
    3115         x =  PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
    3116         if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
    3117                 goto error;
    3118         Py_DECREF(x);
     3115    x =  PyInt_FromLong((long) AL_SPEAKER_PLUS_LINE_IF_TYPE);
     3116    if (x == NULL || PyDict_SetItemString(d, "SPEAKER_PLUS_LINE_IF_TYPE", x) < 0)
     3117        goto error;
     3118    Py_DECREF(x);
    31193119#endif
    31203120#ifdef AL_STEREO
    3121         x =  PyInt_FromLong((long) AL_STEREO);
    3122         if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
    3123                 goto error;
    3124         Py_DECREF(x);
     3121    x =  PyInt_FromLong((long) AL_STEREO);
     3122    if (x == NULL || PyDict_SetItemString(d, "STEREO", x) < 0)
     3123        goto error;
     3124    Py_DECREF(x);
    31253125#endif
    31263126#ifdef AL_STRING_VAL
    3127         x =  PyInt_FromLong((long) AL_STRING_VAL);
    3128         if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
    3129                 goto error;
    3130         Py_DECREF(x);
     3127    x =  PyInt_FromLong((long) AL_STRING_VAL);
     3128    if (x == NULL || PyDict_SetItemString(d, "STRING_VAL", x) < 0)
     3129        goto error;
     3130    Py_DECREF(x);
    31313131#endif
    31323132#ifdef AL_SUBSYSTEM
    3133         x =  PyInt_FromLong((long) AL_SUBSYSTEM);
    3134         if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
    3135                 goto error;
    3136         Py_DECREF(x);
     3133    x =  PyInt_FromLong((long) AL_SUBSYSTEM);
     3134    if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM", x) < 0)
     3135        goto error;
     3136    Py_DECREF(x);
    31373137#endif
    31383138#ifdef AL_SUBSYSTEM_TYPE
    3139         x =  PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
    3140         if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
    3141                 goto error;
    3142         Py_DECREF(x);
     3139    x =  PyInt_FromLong((long) AL_SUBSYSTEM_TYPE);
     3140    if (x == NULL || PyDict_SetItemString(d, "SUBSYSTEM_TYPE", x) < 0)
     3141        goto error;
     3142    Py_DECREF(x);
    31433143#endif
    31443144#ifdef AL_SYNC_INPUT_TO_AES
    3145         x =  PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
    3146         if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
    3147                 goto error;
    3148         Py_DECREF(x);
     3145    x =  PyInt_FromLong((long) AL_SYNC_INPUT_TO_AES);
     3146    if (x == NULL || PyDict_SetItemString(d, "SYNC_INPUT_TO_AES", x) < 0)
     3147        goto error;
     3148    Py_DECREF(x);
    31493149#endif
    31503150#ifdef AL_SYNC_OUTPUT_TO_AES
    3151         x =  PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
    3152         if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
    3153                 goto error;
    3154         Py_DECREF(x);
     3151    x =  PyInt_FromLong((long) AL_SYNC_OUTPUT_TO_AES);
     3152    if (x == NULL || PyDict_SetItemString(d, "SYNC_OUTPUT_TO_AES", x) < 0)
     3153        goto error;
     3154    Py_DECREF(x);
    31553155#endif
    31563156#ifdef AL_SYSTEM
    3157         x =  PyInt_FromLong((long) AL_SYSTEM);
    3158         if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
    3159                 goto error;
    3160         Py_DECREF(x);
     3157    x =  PyInt_FromLong((long) AL_SYSTEM);
     3158    if (x == NULL || PyDict_SetItemString(d, "SYSTEM", x) < 0)
     3159        goto error;
     3160    Py_DECREF(x);
    31613161#endif
    31623162#ifdef AL_SYSTEM_TYPE
    3163         x =  PyInt_FromLong((long) AL_SYSTEM_TYPE);
    3164         if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
    3165                 goto error;
    3166         Py_DECREF(x);
     3163    x =  PyInt_FromLong((long) AL_SYSTEM_TYPE);
     3164    if (x == NULL || PyDict_SetItemString(d, "SYSTEM_TYPE", x) < 0)
     3165        goto error;
     3166    Py_DECREF(x);
    31673167#endif
    31683168#ifdef AL_TEST_IF_TYPE
    3169         x =  PyInt_FromLong((long) AL_TEST_IF_TYPE);
    3170         if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
    3171                 goto error;
    3172         Py_DECREF(x);
     3169    x =  PyInt_FromLong((long) AL_TEST_IF_TYPE);
     3170    if (x == NULL || PyDict_SetItemString(d, "TEST_IF_TYPE", x) < 0)
     3171        goto error;
     3172    Py_DECREF(x);
    31733173#endif
    31743174#ifdef AL_TYPE
    3175         x =  PyInt_FromLong((long) AL_TYPE);
    3176         if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
    3177                 goto error;
    3178         Py_DECREF(x);
     3175    x =  PyInt_FromLong((long) AL_TYPE);
     3176    if (x == NULL || PyDict_SetItemString(d, "TYPE", x) < 0)
     3177        goto error;
     3178    Py_DECREF(x);
    31793179#endif
    31803180#ifdef AL_TYPE_BIT
    3181         x =  PyInt_FromLong((long) AL_TYPE_BIT);
    3182         if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
    3183                 goto error;
    3184         Py_DECREF(x);
     3181    x =  PyInt_FromLong((long) AL_TYPE_BIT);
     3182    if (x == NULL || PyDict_SetItemString(d, "TYPE_BIT", x) < 0)
     3183        goto error;
     3184    Py_DECREF(x);
    31853185#endif
    31863186#ifdef AL_UNUSED_COUNT
    3187         x =  PyInt_FromLong((long) AL_UNUSED_COUNT);
    3188         if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
    3189                 goto error;
    3190         Py_DECREF(x);
     3187    x =  PyInt_FromLong((long) AL_UNUSED_COUNT);
     3188    if (x == NULL || PyDict_SetItemString(d, "UNUSED_COUNT", x) < 0)
     3189        goto error;
     3190    Py_DECREF(x);
    31913191#endif
    31923192#ifdef AL_UNUSED_PORTS
    3193         x =  PyInt_FromLong((long) AL_UNUSED_PORTS);
    3194         if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
    3195                 goto error;
    3196         Py_DECREF(x);
     3193    x =  PyInt_FromLong((long) AL_UNUSED_PORTS);
     3194    if (x == NULL || PyDict_SetItemString(d, "UNUSED_PORTS", x) < 0)
     3195        goto error;
     3196    Py_DECREF(x);
    31973197#endif
    31983198#ifdef AL_VARIABLE_MCLK_TYPE
    3199         x =  PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
    3200         if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
    3201                 goto error;
    3202         Py_DECREF(x);
     3199    x =  PyInt_FromLong((long) AL_VARIABLE_MCLK_TYPE);
     3200    if (x == NULL || PyDict_SetItemString(d, "VARIABLE_MCLK_TYPE", x) < 0)
     3201        goto error;
     3202    Py_DECREF(x);
    32033203#endif
    32043204#ifdef AL_VECTOR_VAL
    3205         x =  PyInt_FromLong((long) AL_VECTOR_VAL);
    3206         if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
    3207                 goto error;
    3208         Py_DECREF(x);
     3205    x =  PyInt_FromLong((long) AL_VECTOR_VAL);
     3206    if (x == NULL || PyDict_SetItemString(d, "VECTOR_VAL", x) < 0)
     3207        goto error;
     3208    Py_DECREF(x);
    32093209#endif
    32103210#ifdef AL_VIDEO_MCLK_TYPE
    3211         x =  PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
    3212         if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
    3213                 goto error;
    3214         Py_DECREF(x);
     3211    x =  PyInt_FromLong((long) AL_VIDEO_MCLK_TYPE);
     3212    if (x == NULL || PyDict_SetItemString(d, "VIDEO_MCLK_TYPE", x) < 0)
     3213        goto error;
     3214    Py_DECREF(x);
    32153215#endif
    32163216#ifdef AL_WORDSIZE
    3217         x =  PyInt_FromLong((long) AL_WORDSIZE);
    3218         if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
    3219                 goto error;
    3220         Py_DECREF(x);
    3221 #endif
    3222 
    3223 #ifdef AL_NO_ELEM               /* IRIX 6 */
    3224         (void) alSetErrorHandler(ErrorHandler);
     3217    x =  PyInt_FromLong((long) AL_WORDSIZE);
     3218    if (x == NULL || PyDict_SetItemString(d, "WORDSIZE", x) < 0)
     3219        goto error;
     3220    Py_DECREF(x);
     3221#endif
     3222
     3223#ifdef AL_NO_ELEM               /* IRIX 6 */
     3224    (void) alSetErrorHandler(ErrorHandler);
    32253225#endif /* AL_NO_ELEM */
    32263226#ifdef OLD_INTERFACE
    3227         (void) ALseterrorhandler(ErrorHandler);
     3227    (void) ALseterrorhandler(ErrorHandler);
    32283228#endif /* OLD_INTERFACE */
    3229        
     3229
    32303230  error:
    3231         return;
    3232 }
     3231    return;
     3232}
Note: See TracChangeset for help on using the changeset viewer.