| >I did not mean an abstract interface was necessary for UGs to access
>function tables, only that one would be required to UGs to access function
>tables exported by some other, non-Csound application hosting the UG. But I
>may be wrong about this...
FUNC's *are* an abstract interface, because the data itself is held in
a pointer to the storage, rather than within the FUNC itself. This
allows other applications to create the data, and then make it
available to Csound UG's by wrapping the data with a FUNC structure,
and putting into the list of tables. Thats the only piece of glue you
need.
There are several places in Quasimodo (e.g. my version of spliner,
that lets you draw your own function tables with the mouse) where I do
exactly this operation: generate the data, call for it to be wrapped
as a FunctionTable, and presto, FunctionTable::find (const char *name)
can find it.
>What do you think about this idea? Would you be open to using this
>JavaCsound kernel in Quasimodo, or merging the two kernels into one (as a
>shared library,
If it means moving away from C++, I'm not in favor of it. If it means
not using a formal grammar, I'm not in favor of it.
In addition, two things I forgot to mention in my quasimodo overview:
* Quasimodo can handle any number of quoted strings in the arguments to an
opcode. It is not limited to one-string-per-call the way that Csound is.
* Quasimodo uses names for function tables and instruments, not numbers,
though the names can be numeric if you so wish.
The first one of these has lots of implications for the parser and
compiler, and requires a dirty trick involving inner knowledge of IEEE
32 bit float format. The second one has less implications, but they
are still significant. I would not give up either of these features gladly.
>it can support any number of external interfaces, including,
>as I have said, Java, VST-2, Buzz machines, etc.).
This is true, and a very desirable goal. But I'm very familiar with
the benefits I've gained from using C++, and I am loathe to abandon
them for the sake of interoperability. Your advocacy on behalf of Java
over C++ is something I would echo on behalf of C++ over C for this
purpose. Managing the complexity of the internal compiler in C is not
impossible, but it is harder.
--p
ps. while i'm here:
* Quasimodo has an abstract interface for its internal DSP object. Porting
Quasimodo to a plugin card with some kind of DSP(s) on it is mostly
just a matter of reimplementing the DSP object. (this is currently an |