# This script generates the Sound interface for Python.
# It uses the "bgen" package to generate C code.
# It execs the file sndgen.py which contain the function definitions
# (sndgen.py was generated by sndscan.py, scanning the <Sound.h> header file).

from macsupport import *


# define our own function and module generators

class SndMixIn: pass

class SndFunction(SndMixIn, OSErrFunctionGenerator): pass
class SndMethod(SndMixIn, OSErrMethodGenerator): pass


# includestuff etc. are imported from macsupport

includestuff = includestuff + """
#include <Carbon/Carbon.h>
"""

initstuff = initstuff + """
"""


# define types used for arguments (in addition to standard and macsupport types)

class SndChannelPtrType(OpaqueByValueType):
    def declare(self, name):
        # Initializing all SndChannelPtr objects to 0 saves
        # special-casing NewSndChannel(), where it is formally an
        # input-output parameter but we treat it as output-only
        # (since Python users are not supposed to allocate memory)
        Output("SndChannelPtr %s = 0;", name)

SndChannelPtr = SndChannelPtrType('SndChannelPtr', 'SndCh')

SndCommand = OpaqueType('SndCommand', 'SndCmd')
SndCommand_ptr = OpaqueType('SndCommand', 'SndCmd')
SndListHandle = OpaqueByValueType("SndListHandle", "ResObj")
SPBPtr = OpaqueByValueType("SPBPtr", "SPBObj")
ModalFilterUPP = FakeType("(ModalFilterUPP)0")

#
# NOTE: the following is pretty dangerous. For void pointers we pass buffer addresses
# but we have no way to check that the buffer is big enough. This is the same problem
# as in C, though (but Pythoneers may not be suspecting this...)
void_ptr = Type("void *", "w")

class SndCallBackType(InputOnlyType):
    def __init__(self):
        Type.__init__(self, 'PyObject*', 'O')
    def getargsCheck(self, name):
        Output("if (%s != Py_None && !PyCallable_Check(%s))", name, name)
        OutLbrace()
        Output('PyErr_SetString(PyExc_TypeError, "callback must be callable");')
        Output("goto %s__error__;", name)
        OutRbrace()
    def passInput(self, name):
        return "NewSndCallBackUPP(SndCh_UserRoutine)"
    def cleanup(self, name):
        # XXX This knows it is executing inside the SndNewChannel wrapper
        Output("if (_res != NULL && %s != Py_None)", name)
        OutLbrace()
        Output("SndChannelObject *p = (SndChannelObject *)_res;")
        Output("p->ob_itself->userInfo = (long)p;")
        Output("Py_INCREF(%s);", name)
        Output("p->ob_callback = %s;", name)
        OutRbrace()
        DedentLevel()
        Output(" %s__error__: ;", name)
        IndentLevel()

SndCallBackProcPtr = SndCallBackType()
SndCallBackUPP = SndCallBackProcPtr

SndCompletionProcPtr = FakeType('(SndCompletionProcPtr)0') # XXX
SndCompletionUPP = SndCompletionProcPtr

##InOutBuf128 = FixedInputOutputBufferType(128)
StateBlock = StructInputOutputBufferType('StateBlock')

AudioSelectionPtr = FakeType('0') # XXX

ProcPtr = FakeType('0') # XXX
FilePlayCompletionUPP = FakeType('0') # XXX

SCStatus = StructOutputBufferType('SCStatus')
SMStatus = StructOutputBufferType('SMStatus')
CompressionInfo = StructOutputBufferType('CompressionInfo')

includestuff = includestuff + """
/* Convert a SndCommand argument */
static int
SndCmd_Convert(PyObject *v, SndCommand *pc)
{
        int len;
        pc->param1 = 0;
        pc->param2 = 0;
        if (PyTuple_Check(v)) {
                if (PyArg_ParseTuple(v, "h|hl", &pc->cmd, &pc->param1, &pc->param2))
                        return 1;
                PyErr_Clear();
                return PyArg_ParseTuple(v, "Hhs#", &pc->cmd, &pc->param1, &pc->param2, &len);
        }
        return PyArg_Parse(v, "H", &pc->cmd);
}

static pascal void SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd); /* Forward */
static pascal void SPB_completion(SPBPtr my_spb); /* Forward */
"""


finalstuff = finalstuff + """
/* Routine passed to Py_AddPendingCall -- call the Python callback */
static int
SndCh_CallCallBack(void *arg)
{
        SndChannelObject *p = (SndChannelObject *)arg;
        PyObject *args;
        PyObject *res;
        args = Py_BuildValue("(O(hhl))",
                             p, p->ob_cmd.cmd, p->ob_cmd.param1, p->ob_cmd.param2);
        res = PyEval_CallObject(p->ob_callback, args);
        Py_DECREF(args);
        if (res == NULL)
                return -1;
        Py_DECREF(res);
        return 0;
}

/* Routine passed to NewSndChannel -- schedule a call to SndCh_CallCallBack */
static pascal void
SndCh_UserRoutine(SndChannelPtr chan, SndCommand *cmd)
{
        SndChannelObject *p = (SndChannelObject *)(chan->userInfo);
        if (p->ob_callback != NULL) {
                long A5 = SetA5(p->ob_A5);
                p->ob_cmd = *cmd;
                Py_AddPendingCall(SndCh_CallCallBack, (void *)p);
                SetA5(A5);
        }
}

/* SPB callbacks - Schedule callbacks to Python */
static int
SPB_CallCallBack(void *arg)
{
        SPBObject *p = (SPBObject *)arg;
        PyObject *args;
        PyObject *res;

        if ( p->ob_thiscallback == 0 ) return 0;
        args = Py_BuildValue("(O)", p);
        res = PyEval_CallObject(p->ob_thiscallback, args);
        p->ob_thiscallback = 0;
        Py_DECREF(args);
        if (res == NULL)
                return -1;
        Py_DECREF(res);
        return 0;
}

static pascal void
SPB_completion(SPBPtr my_spb)
{
        SPBObject *p = (SPBObject *)(my_spb->userLong);

        if (p && p->ob_completion) {
                long A5 = SetA5(p->ob_A5);
                p->ob_thiscallback = p->ob_completion;  /* Hope we cannot get two at the same time */
                Py_AddPendingCall(SPB_CallCallBack, (void *)p);
                SetA5(A5);
        }
}

"""


# create the module and object definition and link them

class SndObjectDefinition(PEP252Mixin, ObjectDefinition):

    def outputStructMembers(self):
        ObjectDefinition.outputStructMembers(self)
        Output("/* Members used to implement callbacks: */")
        Output("PyObject *ob_callback;")
        Output("long ob_A5;");
        Output("SndCommand ob_cmd;")

    def outputInitStructMembers(self):
        ObjectDefinition.outputInitStructMembers(self)
        Output("it->ob_callback = NULL;")
        Output("it->ob_A5 = SetCurrentA5();");

    def outputCleanupStructMembers(self):
        ObjectDefinition.outputCleanupStructMembers(self)
        Output("Py_XDECREF(self->ob_callback);")

    def outputFreeIt(self, itselfname):
        Output("SndDisposeChannel(%s, 1);", itselfname)

    def outputConvert(self):
        pass # Not needed

#

class SpbObjectDefinition(PEP252Mixin, ObjectDefinition):
    getsetlist = [
            (
            'inRefNum',
            'return Py_BuildValue("l", self->ob_spb.inRefNum);',
            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.inRefNum);',
            None,
            ), (
            'count',
            'return Py_BuildValue("l", self->ob_spb.count);',
            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.count);',
            None
            ), (
            'milliseconds',
            'return Py_BuildValue("l", self->ob_spb.milliseconds);',
            'return -1 + PyArg_Parse(v, "l", &self->ob_spb.milliseconds);',
            None,
            ), (
            'error',
            'return Py_BuildValue("h", self->ob_spb.error);',
            None,
            None
            ), (
            'completionRoutine',
            None,
            """self->ob_spb.completionRoutine = NewSICompletionUPP(SPB_completion);
            self->ob_completion = v;
            Py_INCREF(v);
            return 0;""",
            None,
            )]

    def outputStructMembers(self):
        Output("/* Members used to implement callbacks: */")
        Output("PyObject *ob_completion;")
        Output("PyObject *ob_interrupt;")
        Output("PyObject *ob_thiscallback;");
        Output("long ob_A5;")
        Output("SPB ob_spb;")

    def outputNew(self):
        Output()
        Output("%sPyObject *%s_New(void)", self.static, self.prefix)
        OutLbrace()
        Output("%s *it;", self.objecttype)
        self.outputCheckNewArg()
        Output("it = PyObject_NEW(%s, &%s);", self.objecttype, self.typename)
        Output("if (it == NULL) return NULL;")
        self.outputInitStructMembers()
        Output("return (PyObject *)it;")
        OutRbrace()

    def outputInitStructMembers(self):
        Output("it->ob_completion = NULL;")
        Output("it->ob_interrupt = NULL;")
        Output("it->ob_thiscallback = NULL;")
        Output("it->ob_A5 = SetCurrentA5();")
        Output("memset((char *)&it->ob_spb, 0, sizeof(it->ob_spb));")
        Output("it->ob_spb.userLong = (long)it;")

    def outputCleanupStructMembers(self):
        ObjectDefinition.outputCleanupStructMembers(self)
        Output("self->ob_spb.userLong = 0;")
        Output("self->ob_thiscallback = 0;")
        Output("Py_XDECREF(self->ob_completion);")
        Output("Py_XDECREF(self->ob_interrupt);")

    def outputConvert(self):
        Output("%sint %s_Convert(PyObject *v, %s *p_itself)", self.static, self.prefix, self.itselftype)
        OutLbrace()
        self.outputCheckConvertArg()
        Output("if (!%s_Check(v))", self.prefix)
        OutLbrace()
        Output('PyErr_SetString(PyExc_TypeError, "%s required");', self.name)
        Output("return 0;")
        OutRbrace()
        Output("*p_itself = &((%s *)v)->ob_spb;", self.objecttype)
        Output("return 1;")
        OutRbrace()


sndobject = SndObjectDefinition('SndChannel', 'SndCh', 'SndChannelPtr')
spbobject = SpbObjectDefinition('SPB', 'SPBObj', 'SPBPtr')
spbgenerator = ManualGenerator("SPB", "_res = SPBObj_New(); return _res;")
module = MacModule('_Snd', 'Snd', includestuff, finalstuff, initstuff)
module.addobject(sndobject)
module.addobject(spbobject)
module.add(spbgenerator)


# create lists of functions and object methods

functions = []
sndmethods = []


# populate the lists

execfile('sndgen.py')


# add the functions and methods to the module and object, respectively

for f in functions: module.add(f)
for f in sndmethods: sndobject.add(f)


# generate output

SetOutputFileName('_Sndmodule.c')
module.generate()