Mac/Modules/snd/sndsupport.py

   1 # This script generates the Sound interface for Python.
   2 # It uses the "bgen" package to generate C code.
   3 # It execs the file sndgen.py which contain the function definitions
   4 # (sndgen.py was generated by sndscan.py, scanning the <Sound.h> header file).
   5
   6 from macsupport import *
   7
   8
   9 # define our own function and module generators
  10
  11 class SndMixIn: pass
  12
  13 class SndFunction(SndMixIn, OSErrFunctionGenerator): pass
  14 class SndMethod(SndMixIn, OSErrMethodGenerator): pass
  15
  16
  17 # includestuff etc. are imported from macsupport
  18
  19 includestuff = includestuff + """
  20 #include <Carbon/Carbon.h>
  21 """
  22
  23 initstuff = initstuff + """
  24 """
  25
  26
  27 # define types used for arguments (in addition to standard and macsupport types)
  28
  29 class SndChannelPtrType(OpaqueByValueType):
  30     def declare(self, name):
  31         # Initializing all SndChannelPtr objects to 0 saves
  32         # special-casing NewSndChannel(), where it is formally an
  33         # input-output parameter but we treat it as output-only
  34         # (since Python users are not supposed to allocate memory)
  35         Output("SndChannelPtr %s = 0;", name)
  36
  37 SndChannelPtr = SndChannelPtrType('SndChannelPtr', 'SndCh')
  38
  39 SndCommand = OpaqueType('SndCommand', 'SndCmd')
  40 SndCommand_ptr = OpaqueType('SndCommand', 'SndCmd')
  41 SndListHandle = OpaqueByValueType("SndListHandle", "ResObj")
  42 SPBPtr = OpaqueByValueType("SPBPtr", "SPBObj")
  43 ModalFilterUPP = FakeType("(ModalFilterUPP)0")
  44
  45 #
  46 # NOTE: the following is pretty dangerous. For void pointers we pass buffer addresses
  47 # but we have no way to check that the buffer is big enough. This is the same problem
  48 # as in C, though (but Pythoneers may not be suspecting this...)
  49 void_ptr = Type("void *", "w")
  50
  51 class SndCallBackType(InputOnlyType):
  52     def __init__(self):
  53         Type.__init__(self, 'PyObject*', 'O')
  54     def getargsCheck(self, name):
  55         Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
  56         OutLbrace()
  57         Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
  58         Output("goto %s__error__;", name)
  59         OutRbrace()
  60     def passInput(self, name):
  61         return "NewSndCallBackUPP(SndCh_UserRoutine)"
  62     def cleanup(self, name):
  63         # XXX This knows it is executing inside the SndNewChannel wrapper
  64         Output("if (_res != NULL && %s != Py_None)", name)
  65         OutLbrace()
  66         Output("SndChannelObject *p = (SndChannelObject *)_res;")
  67         Output("p->ob_itself->userInfo = (long)p;")
  68         Output("Py_INCREF(%s);", name)
  69         Output("p->ob_callback = %s;", name)
  70         OutRbrace()
  71         DedentLevel()
  72         Output(" %s__error__: ;", name)
  73         IndentLevel()
  74
  75 SndCallBackProcPtr = SndCallBackType()
  76 SndCallBackUPP = SndCallBackProcPtr
  77
  78 SndCompletionProcPtr = FakeType('(SndCompletionProcPtr)0') # XXX
  79 SndCompletionUPP = SndCompletionProcPtr
  80
  81 ##InOutBuf128 = FixedInputOutputBufferType(128)
  82 StateBlock = StructInputOutputBufferType('StateBlock')
  83
  84 AudioSelectionPtr = FakeType('0') # XXX
  85
  86 ProcPtr = FakeType('0') # XXX
  87 FilePlayCompletionUPP = FakeType('0') # XXX
  88
  89 SCStatus = StructOutputBufferType('SCStatus')
  90 SMStatus = StructOutputBufferType('SMStatus')
  91 CompressionInfo = StructOutputBufferType('CompressionInfo')
  92
  93 includestuff = includestuff + """
  94 /* Convert a SndCommand argument */
  95 static int
  96 SndCmd_Convert(PyObject *v, SndCommand *pc)
  97 {
  98         int len;
  99         pc->param1 = 0;
 100         pc->param2 = 0;
 101         if (PyTuple_Check(v)) {
 102                 if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
 103                         return 1;
 104                 PyErr_Clear();
 105                 return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
 106         }
 107         return PyArg_Parse(v, "H", &pc->cmd);
 108 }
 109
 110 static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
 111 static pascal void SPB_completion(SPBPtr my_spb); /* Forward */
 112 """
 113
 114
 115 finalstuff = finalstuff + """
 116 /* Routine passed to Py_AddPendingCall -- call the Python callback */
 117 static int
 118 SndCh_CallCallBack(void *arg)
 119 {
 120         SndChannelObject *p = (SndChannelObject *)arg;
 121         PyObject *args;
 122         PyObject *res;
 123         args = Py_BuildValue("(O(hhl))",
 124                              p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
 125         res = PyEval_CallObject(p->ob_callback, args);
 126         Py_DECREF(args);
 127         if (res == NULL)
 128                 return -1;
 129         Py_DECREF(res);
 130         return 0;
 131 }
 132
 133 /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
 134 static pascal void
 135 SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
 136 {
 137         SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
 138         if (p->ob_callback != NULL) {
 139                 long A5 = SetA5(p->ob_A5);
 140                 p->ob_cmd = *cmd;
 141                 Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
 142                 SetA5(A5);
 143         }
 144 }
 145
 146 /* SPB callbacks - Schedule callbacks to Python */
 147 static int
 148 SPB_CallCallBack(void *arg)
 149 {
 150         SPBObject *p = (SPBObject *)arg;
 151         PyObject *args;
 152         PyObject *res;
 153
 154         if ( p->ob_thiscallback == 0 ) return 0;
 155         args = Py_BuildValue("(O)", p);
 156         res = PyEval_CallObject(p->ob_thiscallback, args);
 157         p->ob_thiscallback = 0;
 158         Py_DECREF(args);
 159         if (res == NULL)
 160                 return -1;
 161         Py_DECREF(res);
 162         return 0;
 163 }
 164
 165 static pascal void
 166 SPB_completion(SPBPtr my_spb)
 167 {
 168         SPBObject *p = (SPBObject *)(my_spb->userLong);
 169
 170         if (p && p->ob_completion) {
 171                 long A5 = SetA5(p->ob_A5);
 172                 p->ob_thiscallback = p->ob_completion;  /* Hope we cannot get two at the same time */
 173                 Py_AddPendingCall(SPB_CallCallBack, (void *)p);
 174                 SetA5(A5);
 175         }
 176 }
 177
 178 """
 179
 180
 181 # create the module and object definition and link them
 182
 183 class SndObjectDefinition(PEP252Mixin, ObjectDefinition):
 184
 185     def outputStructMembers(self):
 186         ObjectDefinition.outputStructMembers(self)
 187         Output("/* Members used to implement callbacks: */")
 188         Output("PyObject *ob_callback;")
 189         Output("long ob_A5;");
 190         Output("SndCommand ob_cmd;")
 191
 192     def outputInitStructMembers(self):
 193         ObjectDefinition.outputInitStructMembers(self)
 194         Output("it->ob_callback = NULL;")
 195         Output("it->ob_A5 = SetCurrentA5();");
 196
 197     def outputCleanupStructMembers(self):
 198         ObjectDefinition.outputCleanupStructMembers(self)
 199         Output("Py_XDECREF(self->ob_callback);")
 200
 201     def outputFreeIt(self, itselfname):
 202         Output("SndDisposeChannel(%s, 1);", itselfname)
 203
 204     def outputConvert(self):
 205         pass # Not needed
 206
 207 #
 208
 209 class SpbObjectDefinition(PEP252Mixin, ObjectDefinition):
 210     getsetlist = [
 211             (
 212             'inRefNum',
 213             'return Py_BuildValue("l", self->ob_spb.inRefNum);',
 214             'return -1 + PyArg_Parse(v, "l", &self->ob_spb.inRefNum);',
 215             None,
 216             ), (
 217             'count',
 218             'return Py_BuildValue("l", self->ob_spb.count);',
 219             'return -1 + PyArg_Parse(v, "l", &self->ob_spb.count);',
 220             None
 221             ), (
 222             'milliseconds',
 223             'return Py_BuildValue("l", self->ob_spb.milliseconds);',
 224             'return -1 + PyArg_Parse(v, "l", &self->ob_spb.milliseconds);',
 225             None,
 226             ), (
 227             'error',
 228             'return Py_BuildValue("h", self->ob_spb.error);',
 229             None,
 230             None
 231             ), (
 232             'completionRoutine',
 233             None,
 234             """self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
 235             self->ob_completion = v;
 236             Py_INCREF(v);
 237             return 0;""",
 238             None,
 239             )]
 240
 241     def outputStructMembers(self):
 242         Output("/* Members used to implement callbacks: */")
 243         Output("PyObject *ob_completion;")
 244         Output("PyObject *ob_interrupt;")
 245         Output("PyObject *ob_thiscallback;");
 246         Output("long ob_A5;")
 247         Output("SPB ob_spb;")
 248
 249     def outputNew(self):
 250         Output()
 251         Output("%sPyObject *%s_New(void)", self.static, self.prefix)
 252         OutLbrace()
 253         Output("%s *it;", self.objecttype)
 254         self.outputCheckNewArg()
 255         Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
 256         Output("if (it == NULL) return NULL;")
 257         self.outputInitStructMembers()
 258         Output("return (PyObject *)it;")
 259         OutRbrace()
 260
 261     def outputInitStructMembers(self):
 262         Output("it->ob_completion = NULL;")
 263         Output("it->ob_interrupt = NULL;")
 264         Output("it->ob_thiscallback = NULL;")
 265         Output("it->ob_A5 = SetCurrentA5();")
 266         Output("memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));")
 267         Output("it->ob_spb.userLong = (long)it;")
 268
 269     def outputCleanupStructMembers(self):
 270         ObjectDefinition.outputCleanupStructMembers(self)
 271         Output("self->ob_spb.userLong = 0;")
 272         Output("self->ob_thiscallback = 0;")
 273         Output("Py_XDECREF(self->ob_completion);")
 274         Output("Py_XDECREF(self->ob_interrupt);")
 275
 276     def outputConvert(self):
 277         Output("%sint %s_Convert(PyObject *v, %s *p_itself)", self.static, self.prefix, self.itselftype)
 278         OutLbrace()
 279         self.outputCheckConvertArg()
 280         Output("if (!%s_Check(v))", self.prefix)
 281         OutLbrace()
 282         Output('PyErr_SetString(PyExc_TypeError, "%s required");', self.name)
 283         Output("return 0;")
 284         OutRbrace()
 285         Output("*p_itself = &((%s *)v)->ob_spb;", self.objecttype)
 286         Output("return 1;")
 287         OutRbrace()
 288
 289
 290 sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
 291 spbobject = SpbObjectDefinition('SPB', 'SPBObj', 'SPBPtr')
 292 spbgenerator = ManualGenerator("SPB", "_res = SPBObj_New(); return _res;")
 293 module = MacModule('_Snd', 'Snd', includestuff, finalstuff, initstuff)
 294 module.addobject(sndobject)
 295 module.addobject(spbobject)
 296 module.add(spbgenerator)
 297
 298
 299 # create lists of functions and object methods
 300
 301 functions = []
 302 sndmethods = []
 303
 304
 305 # populate the lists
 306
 307 execfile('sndgen.py')
 308
 309
 310 # add the functions and methods to the module and object, respectively
 311
 312 for f in functions: module.add(f)
 313 for f in sndmethods: sndobject.add(f)
 314
 315
 316 # generate output
 317
 318 SetOutputFileName('_Sndmodule.c')
 319 module.generate()