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 <Sound.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
  44 #
  45 # NOTE: the following is pretty dangerous. For void pointers we pass buffer addresses
  46 # but we have no way to check that the buffer is big enough. This is the same problem
  47 # as in C, though (but Pythoneers may not be suspecting this...)
  48 void_ptr = Type("void *", "w")
  49
  50 class SndCallBackType(InputOnlyType):
  51         def __init__(self):
  52                 Type.__init__(self, 'PyObject*', 'O')
  53         def getargsCheck(self, name):
  54                 Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
  55                 OutLbrace()
  56                 Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
  57                 Output("goto %s__error__;", name)
  58                 OutRbrace()
  59         def passInput(self, name):
  60                 return "NewSndCallBackProc(SndCh_UserRoutine)"
  61         def cleanup(self, name):
  62                 # XXX This knows it is executing inside the SndNewChannel wrapper
  63                 Output("if (_res != NULL && %s != Py_None)", name)
  64                 OutLbrace()
  65                 Output("SndChannelObject *p = (SndChannelObject *)_res;")
  66                 Output("p->ob_itself->userInfo = (long)p;")
  67                 Output("Py_INCREF(%s);", name)
  68                 Output("p->ob_callback = %s;", name)
  69                 OutRbrace()
  70                 DedentLevel()
  71                 Output(" %s__error__: ;", name)
  72                 IndentLevel()
  73
  74 SndCallBackProcPtr = SndCallBackType()
  75 SndCallBackUPP = SndCallBackProcPtr
  76
  77 SndCompletionProcPtr = FakeType('(SndCompletionProcPtr)0') # XXX
  78 SndCompletionUPP = SndCompletionProcPtr
  79
  80 ##InOutBuf128 = FixedInputOutputBufferType(128)
  81 StateBlock = StructInputOutputBufferType('StateBlock')
  82
  83 AudioSelectionPtr = FakeType('0') # XXX
  84
  85 ProcPtr = FakeType('0') # XXX
  86 FilePlayCompletionUPP = FakeType('0') # XXX
  87
  88 SCStatus = StructOutputBufferType('SCStatus')
  89 SMStatus = StructOutputBufferType('SMStatus')
  90 CompressionInfo = StructOutputBufferType('CompressionInfo')
  91
  92 includestuff = includestuff + """
  93 #include <OSUtils.h> /* for Set(Current)A5 */
  94
  95 /* Create a SndCommand object (an (int, int, int) tuple) */
  96 static PyObject *
  97 SndCmd_New(SndCommand *pc)
  98 {
  99         return Py_BuildValue("hhl", pc->cmd, pc->param1, pc->param2);
 100 }
 101
 102 /* Convert a SndCommand argument */
 103 static int
 104 SndCmd_Convert(PyObject *v, SndCommand *pc)
 105 {
 106         int len;
 107         pc->param1 = 0;
 108         pc->param2 = 0;
 109         if (PyTuple_Check(v)) {
 110                 if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
 111                         return 1;
 112                 PyErr_Clear();
 113                 return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
 114         }
 115         return PyArg_Parse(v, "H", &pc->cmd);
 116 }
 117
 118 static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
 119 static pascal void SPB_completion(SPBPtr my_spb); /* Forward */
 120 static pascal void SPB_interrupt(SPBPtr my_spb); /* Forward */
 121 """
 122
 123
 124 finalstuff = finalstuff + """
 125 /* Routine passed to Py_AddPendingCall -- call the Python callback */
 126 static int
 127 SndCh_CallCallBack(arg)
 128         void *arg;
 129 {
 130         SndChannelObject *p = (SndChannelObject *)arg;
 131         PyObject *args;
 132         PyObject *res;
 133         args = Py_BuildValue("(O(hhl))",
 134                              p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
 135         res = PyEval_CallObject(p->ob_callback, args);
 136         Py_DECREF(args);
 137         if (res == NULL)
 138                 return -1;
 139         Py_DECREF(res);
 140         return 0;
 141 }
 142
 143 /* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
 144 static pascal void
 145 SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
 146 {
 147         SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
 148         if (p->ob_callback != NULL) {
 149                 long A5 = SetA5(p->ob_A5);
 150                 p->ob_cmd = *cmd;
 151                 Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
 152                 SetA5(A5);
 153         }
 154 }
 155
 156 /* SPB callbacks - Schedule callbacks to Python */
 157 static int
 158 SPB_CallCallBack(arg)
 159         void *arg;
 160 {
 161         SPBObject *p = (SPBObject *)arg;
 162         PyObject *args;
 163         PyObject *res;
 164
 165         if ( p->ob_thiscallback == 0 ) return 0;
 166         args = Py_BuildValue("(O)", p);
 167         res = PyEval_CallObject(p->ob_thiscallback, args);
 168         p->ob_thiscallback = 0;
 169         Py_DECREF(args);
 170         if (res == NULL)
 171                 return -1;
 172         Py_DECREF(res);
 173         return 0;
 174 }
 175
 176 static pascal void
 177 SPB_completion(SPBPtr my_spb)
 178 {
 179         SPBObject *p = (SPBObject *)(my_spb->userLong);
 180
 181         if (p && p->ob_completion) {
 182                 long A5 = SetA5(p->ob_A5);
 183                 p->ob_thiscallback = p->ob_completion;  /* Hope we cannot get two at the same time */
 184                 Py_AddPendingCall(SPB_CallCallBack, (void *)p);
 185                 SetA5(A5);
 186         }
 187 }
 188
 189 static pascal void
 190 SPB_interrupt(SPBPtr my_spb)
 191 {
 192         SPBObject *p = (SPBObject *)(my_spb->userLong);
 193
 194         if (p && p->ob_interrupt) {
 195                 long A5 = SetA5(p->ob_A5);
 196                 p->ob_thiscallback = p->ob_interrupt;   /* Hope we cannot get two at the same time */
 197                 Py_AddPendingCall(SPB_CallCallBack, (void *)p);
 198                 SetA5(A5);
 199         }
 200 }
 201 """
 202
 203
 204 # create the module and object definition and link them
 205
 206 class SndObjectDefinition(ObjectDefinition):
 207
 208         def outputStructMembers(self):
 209                 ObjectDefinition.outputStructMembers(self)
 210                 Output("/* Members used to implement callbacks: */")
 211                 Output("PyObject *ob_callback;")
 212                 Output("long ob_A5;");
 213                 Output("SndCommand ob_cmd;")
 214
 215         def outputInitStructMembers(self):
 216                 ObjectDefinition.outputInitStructMembers(self)
 217                 Output("it->ob_callback = NULL;")
 218                 Output("it->ob_A5 = SetCurrentA5();");
 219
 220         def outputCleanupStructMembers(self):
 221                 ObjectDefinition.outputCleanupStructMembers(self)
 222                 Output("Py_XDECREF(self->ob_callback);")
 223
 224         def outputFreeIt(self, itselfname):
 225                 Output("SndDisposeChannel(%s, 1);", itselfname)
 226
 227 #
 228
 229 class SpbObjectDefinition(ObjectDefinition):
 230
 231         def outputStructMembers(self):
 232                 Output("/* Members used to implement callbacks: */")
 233                 Output("PyObject *ob_completion;")
 234                 Output("PyObject *ob_interrupt;")
 235                 Output("PyObject *ob_thiscallback;");
 236                 Output("long ob_A5;")
 237                 Output("SPB ob_spb;")
 238
 239         def outputNew(self):
 240                 Output()
 241                 Output("%sPyObject *%s_New()", self.static, self.prefix)
 242                 OutLbrace()
 243                 Output("%s *it;", self.objecttype)
 244                 self.outputCheckNewArg()
 245                 Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
 246                 Output("if (it == NULL) return NULL;")
 247                 self.outputInitStructMembers()
 248                 Output("return (PyObject *)it;")
 249                 OutRbrace()
 250
 251         def outputInitStructMembers(self):
 252                 Output("it->ob_completion = NULL;")
 253                 Output("it->ob_interrupt = NULL;")
 254                 Output("it->ob_thiscallback = NULL;")
 255                 Output("it->ob_A5 = SetCurrentA5();")
 256                 Output("memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));")
 257                 Output("it->ob_spb.userLong = (long)it;")
 258
 259         def outputCleanupStructMembers(self):
 260                 ObjectDefinition.outputCleanupStructMembers(self)
 261                 Output("self->ob_spb.userLong = 0;")
 262                 Output("self->ob_thiscallback = 0;")
 263                 Output("Py_XDECREF(self->ob_completion);")
 264                 Output("Py_XDECREF(self->ob_interrupt);")
 265
 266         def outputConvert(self):
 267                 Output("%s%s_Convert(v, p_itself)", self.static, self.prefix)
 268                 IndentLevel()
 269                 Output("PyObject *v;")
 270                 Output("%s *p_itself;", self.itselftype)
 271                 DedentLevel()
 272                 OutLbrace()
 273                 self.outputCheckConvertArg()
 274                 Output("if (!%s_Check(v))", self.prefix)
 275                 OutLbrace()
 276                 Output('PyErr_SetString(PyExc_TypeError, "%s required");', self.name)
 277                 Output("return 0;")
 278                 OutRbrace()
 279                 Output("*p_itself = &((%s *)v)->ob_spb;", self.objecttype)
 280                 Output("return 1;")
 281                 OutRbrace()
 282
 283         def outputSetattr(self):
 284                 Output()
 285                 Output("static int %s_setattr(self, name, value)", self.prefix)
 286                 IndentLevel()
 287                 Output("%s *self;", self.objecttype)
 288                 Output("char *name;")
 289                 Output("PyObject *value;")
 290                 DedentLevel()
 291                 OutLbrace()
 292                 self.outputSetattrBody()
 293                 OutRbrace()
 294
 295         def outputSetattrBody(self):
 296                 Output("""
 297         int rv = 0;
 298
 299         if (strcmp(name, "inRefNum") == 0)
 300                 rv = PyArg_Parse(value, "l", &self->ob_spb.inRefNum);
 301         else if (strcmp(name, "count") == 0)
 302                 rv = PyArg_Parse(value, "l", &self->ob_spb.count);
 303         else if (strcmp(name, "milliseconds") == 0)
 304                 rv = PyArg_Parse(value, "l", &self->ob_spb.milliseconds);
 305         else if (strcmp(name, "buffer") == 0)
 306                 rv = PyArg_Parse(value, "w#", &self->ob_spb.bufferPtr, &self->ob_spb.bufferLength);
 307         else if (strcmp(name, "completionRoutine") == 0) {
 308                 self->ob_spb.completionRoutine = NewSICompletionProc(SPB_completion);
 309                 self->ob_completion = value;
 310                 Py_INCREF(value);
 311                 rv = 1;
 312 #if !TARGET_API_MAC_CARBON_NOTYET
 313         } else if (strcmp(name, "interruptRoutine") == 0) {
 314                 self->ob_spb.completionRoutine = NewSIInterruptProc(SPB_interrupt);
 315                 self->ob_interrupt = value;
 316                 Py_INCREF(value);
 317                 rv = 1;
 318 #endif
 319         }
 320         if ( rv ) return 0;
 321         else return -1;""")
 322
 323         def outputGetattrHook(self):
 324                 Output("""
 325                         if (strcmp(name, "inRefNum") == 0)
 326                                 return Py_BuildValue("l", self->ob_spb.inRefNum);
 327                         else if (strcmp(name, "count") == 0)
 328                                 return Py_BuildValue("l", self->ob_spb.count);
 329                         else if (strcmp(name, "milliseconds") == 0)
 330                                 return Py_BuildValue("l", self->ob_spb.milliseconds);
 331                         else if (strcmp(name, "error") == 0)
 332                                 return Py_BuildValue("h", self->ob_spb.error);""")
 333
 334
 335
 336 sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
 337 spbobject = SpbObjectDefinition('SPB', 'SPBObj', 'SPBPtr')
 338 spbgenerator = ManualGenerator("SPB", "return SPBObj_New();")
 339 module = MacModule('Snd', 'Snd', includestuff, finalstuff, initstuff)
 340 module.addobject(sndobject)
 341 module.addobject(spbobject)
 342 module.add(spbgenerator)
 343
 344
 345 # create lists of functions and object methods
 346
 347 functions = []
 348 sndmethods = []
 349
 350
 351 # populate the lists
 352
 353 execfile('sndgen.py')
 354
 355
 356 # add the functions and methods to the module and object, respectively
 357
 358 for f in functions: module.add(f)
 359 for f in sndmethods: sndobject.add(f)
 360
 361
 362 # generate output
 363
 364 SetOutputFileName('Sndmodule.c')
 365 module.generate()