--- /dev/null
+/************************************************************************
+ ************************************************************************
+ FAUST compiler
+ Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
+ ---------------------------------------------------------------------
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ ************************************************************************
+ ************************************************************************/
+
+
+/*****************************************************************************
+ HISTORY
+ 22/01/05 : added int cast in select2 and select3 selection signal
+*****************************************************************************/
+
+
+
+#include "signals.hh"
+
+
+////////////////////////////////////////////////////////////////////////
+/**
+ * Signals
+ *
+ */
+///////////////////////////////////////////////////////////////////////
+
+Tree sigInt(int i) { return tree(i); }
+bool isSigInt(Tree t, int* i) { return isInt(t->node(), i); }
+
+Tree sigReal(double r) { return tree(r); }
+bool isSigReal(Tree t, double* r) { return isDouble(t->node(), r); }
+
+Sym SIGINPUT = symbol ("sigInput");
+Tree sigInput(int i) { return tree(SIGINPUT, tree(i)); }
+bool isSigInput(Tree t, int* i) { Tree x; return isTree(t, SIGINPUT, x) && isInt(x->node(),i); }
+
+Sym SIGOUTPUT = symbol ("sigOutput");
+Tree sigOutput(int i, Tree t0) { return tree(SIGOUTPUT, tree(i), t0); }
+bool isSigOutput(Tree t, int* i, Tree& t0) { Tree x; return isTree(t, SIGOUTPUT, x, t0) && isInt(x->node(),i); }
+
+Sym SIGDELAY1 = symbol ("sigDelay1");
+Tree sigDelay0(Tree t0) { return sigFixDelay(t0, sigInt(0));}
+
+Tree sigDelay1(Tree t0) { return tree(SIGDELAY1, t0); }
+bool isSigDelay1(Tree t, Tree& t0) { return isTree(t, SIGDELAY1, t0); }
+
+Sym SIGFIXDELAY = symbol ("sigFixDelay");
+Tree sigFixDelay(Tree t0, Tree t1) { return tree(SIGFIXDELAY, t0, sigIntCast(t1)); }
+bool isSigFixDelay(Tree t, Tree& t0, Tree& t1) { return isTree(t, SIGFIXDELAY, t0, t1); }
+
+Sym SIGPREFIX = symbol ("sigPrefix");
+Tree sigPrefix(Tree t0, Tree t1) { return tree(SIGPREFIX, t0, t1); }
+bool isSigPrefix(Tree t, Tree& t0, Tree& t1) { return isTree(t, SIGPREFIX, t0, t1); }
+
+Sym SIGIOTA = symbol ("sigIota");
+Tree sigIota(Tree t0) { return tree(SIGIOTA, t0); }
+bool isSigIota(Tree t, Tree& t0) { return isTree(t, SIGIOTA, t0); }
+
+
+// Read only and read write tables
+
+Sym SIGRDTBL = symbol ("SigRDTbl");
+Tree sigRDTbl (Tree t, Tree i) { return tree(SIGRDTBL, t, i); }
+bool isSigRDTbl (Tree s, Tree& t, Tree& i) { return isTree(s, SIGRDTBL, t, i); }
+
+Sym SIGWRTBL = symbol ("SigWRTbl");
+Tree sigWRTbl (Tree id, Tree t, Tree i, Tree s) { return tree(SIGWRTBL, id, t, i, s); }
+bool isSigWRTbl (Tree u, Tree& id, Tree& t, Tree& i, Tree& s) { return isTree(u, SIGWRTBL, id, t, i, s); }
+
+Sym SIGTABLE = symbol ("SigTable");
+Tree sigTable (Tree id, Tree n, Tree sig) { return tree(SIGTABLE, id, n, sig); }
+bool isSigTable (Tree t, Tree& id, Tree& n, Tree& sig) { return isTree(t, SIGTABLE, id, n, sig); }
+
+// Signal used to generate the initial content of a table
+
+Sym SIGGEN = symbol ("SigGen");
+Tree sigGen (Tree s) { return tree(SIGGEN, s); }
+bool isSigGen (Tree t, Tree& x) { return isTree(t, SIGGEN, x); }
+bool isSigGen (Tree t) { return t->node()== Node(SIGGEN); }
+
+
+// Documentator Tables : special version of tables only for documentation purposes
+
+Sym SIGDOCONSTANTTBL = symbol ("SigDocConstantTbl");
+Tree sigDocConstantTbl (Tree n, Tree sig) { return tree(SIGDOCONSTANTTBL, n, sig); }
+bool isSigDocConstantTbl (Tree t, Tree& n, Tree& sig) { return isTree(t, SIGDOCONSTANTTBL, n, sig); }
+
+Sym SIGDOCWRITETBL = symbol ("SigDocWriteTbl");
+Tree sigDocWriteTbl (Tree n, Tree sig, Tree widx, Tree wsig) { return tree(SIGDOCWRITETBL, n, sig, widx, wsig); }
+bool isSigDocWriteTbl (Tree t, Tree& n, Tree& sig, Tree& widx, Tree& wsig) { return isTree(t, SIGDOCWRITETBL, n, sig, widx, wsig); }
+
+Sym SIGDOCACCESSTBL = symbol ("SigDocAccessTbl");
+Tree sigDocAccessTbl (Tree tbl, Tree ridx) { return tree(SIGDOCACCESSTBL, tbl, ridx); }
+bool isSigDocAccessTbl (Tree t, Tree& tbl, Tree& ridx) { return isTree(t, SIGDOCACCESSTBL, tbl, ridx); }
+
+
+// Select on signal among severals
+
+Sym SIGSELECT2 = symbol ("SigSelect2");
+Sym SIGSELECT3 = symbol ("SigSelect3");
+
+Tree sigSelect2 (Tree selector, Tree s1, Tree s2) { return tree(SIGSELECT2, sigIntCast(selector), s1, s2); }
+bool isSigSelect2 (Tree t, Tree& selector, Tree& s1, Tree& s2) { return isTree(t, SIGSELECT2, selector, s1, s2); }
+
+Tree sigSelect3 (Tree selector, Tree s1, Tree s2, Tree s3) { return tree(SIGSELECT3, sigIntCast(selector), s1, s2, s3); }
+bool isSigSelect3 (Tree t, Tree& selector, Tree& s1, Tree& s2, Tree& s3) { return isTree(t, SIGSELECT3, selector, s1, s2, s3); }
+
+
+// multirate
+
+Sym SIGVECTORIZE = symbol ("SigVectorize");
+Tree sigVectorize (Tree n, Tree s) { return tree(SIGVECTORIZE, n, s); }
+bool isSigVectorize (Tree a, Tree& n, Tree& s) { return isTree(a, SIGVECTORIZE, n, s); }
+
+Sym SIGSERIALIZE = symbol ("SigSerialize");
+Tree sigSerialize (Tree s1) { return tree(SIGSERIALIZE, s1); }
+bool isSigSerialize (Tree a, Tree& s1) { return isTree(a, SIGSERIALIZE, s1); }
+
+Sym SIGCONCAT = symbol ("SigConcat");
+Tree sigConcat (Tree s1, Tree s2) { return tree(SIGCONCAT, s1, s2); }
+bool isSigConcat (Tree a, Tree& s1, Tree& s2) { return isTree(a, SIGCONCAT, s1, s2); }
+
+Sym SIGVECTORAT = symbol ("SigVectorAt");
+Tree sigVectorAt (Tree s1, Tree s2) { return tree(SIGVECTORAT, s1, s2); }
+bool isSigVectorAt(Tree a, Tree& s1, Tree& s2) { return isTree(a, SIGVECTORAT, s1, s2); }
+
+Sym SIGUPSAMPLE = symbol ("SigUpsample");
+Tree sigUpSample (Tree n, Tree s) { return tree(SIGUPSAMPLE, n, s); }
+bool isSigUpSample (Tree a, Tree& n, Tree& s) { return isTree(a, SIGUPSAMPLE, n, s); }
+
+Sym SIGDOWNSAMPLE = symbol ("SigDownsample");
+Tree sigDownSample (Tree n, Tree s) { return tree(SIGDOWNSAMPLE, n, s); }
+bool isSigDownSample (Tree a, Tree& n, Tree& s) { return isTree(a, SIGDOWNSAMPLE, n, s); }
+
+
+// Arithmetical operations
+
+Sym SIGBINOP = symbol ("SigBinOp");
+Tree sigBinOp(int op, Tree x, Tree y) { return tree(SIGBINOP, tree(op), x, y); }
+bool isSigBinOp(Tree s, int* op, Tree& x, Tree& y) { Tree t; return isTree(s, SIGBINOP, t, x, y) && isInt(t->node(),op); }
+
+
+// Foreign Functions
+
+Sym SIGFFUN = symbol ("SigFFun");
+Tree sigFFun (Tree ff, Tree largs) { return tree(SIGFFUN, ff, largs); }
+bool isSigFFun (Tree s, Tree& ff, Tree& largs) { return isTree(s, SIGFFUN, ff, largs); }
+
+
+Sym SIGFCONST = symbol ("SigFConst");
+Tree sigFConst (Tree type, Tree name, Tree file) { return tree(SIGFCONST, type, name, file); }
+bool isSigFConst (Tree s) { Tree t,n,f; return isTree(s, SIGFCONST, t, n, f); }
+bool isSigFConst (Tree s, Tree& type, Tree& name, Tree& file) { return isTree(s, SIGFCONST,type, name, file); }
+
+
+Sym SIGFVAR = symbol ("SigFVar");
+Tree sigFVar (Tree type, Tree name, Tree file) { return tree(SIGFVAR, type, name, file); }
+bool isSigFVar (Tree s) { Tree t,n,f; return isTree(s, SIGFVAR, t, n, f); }
+bool isSigFVar (Tree s, Tree& type, Tree& name, Tree& file) { return isTree(s, SIGFVAR, type, name, file); }
+
+// nouvelle version utilisant rec et ref
+
+Sym SIGPROJ = symbol ("SigProj");
+Tree sigProj (int i, Tree rgroup) { return tree(SIGPROJ, tree(i), rgroup); }
+bool isProj (Tree t, int* i, Tree& rgroup) { Tree x; return isTree(t, SIGPROJ, x, rgroup) && isInt(x->node(), i); }
+
+
+// Int and Float casting
+
+Sym SIGINTCAST = symbol ("sigIntCast");
+Sym SIGFLOATCAST = symbol ("sigFloatCast");
+
+Tree sigIntCast(Tree t)
+{
+ Node n = t->node();
+
+ int i; if (isInt(n, &i)) return t;
+ double x; if (isDouble(n, &x)) return tree(int(x));
+ if (isSigIntCast(t)) return t;
+
+ return tree(SIGINTCAST, t);
+}
+
+Tree sigFloatCast(Tree t)
+{
+ Node n = t->node();
+
+ int i; if (isInt(n, &i)) return tree(double(i));
+ double x; if (isDouble(n, &x)) return t;
+ if (isSigFloatCast(t)) return t;
+ if (isSigInput(t, &i)) return t;
+
+ return tree(SIGFLOATCAST, t);
+}
+
+//Tree sigFloatCast(Tree t) { return isSigFloatCast(t)? t : tree(SIGFLOATCAST, t); }
+
+bool isSigIntCast(Tree t) { Tree x; return isTree(t, SIGINTCAST, x); }
+bool isSigIntCast(Tree t, Tree& x) { return isTree(t, SIGINTCAST, x); }
+
+bool isSigFloatCast(Tree t) { Tree x; return isTree(t, SIGFLOATCAST, x);}
+bool isSigFloatCast(Tree t, Tree& x) { return isTree(t, SIGFLOATCAST, x); }
+
+
+
+
+/*****************************************************************************
+ User Interface Elements
+*****************************************************************************/
+
+Sym SIGBUTTON = symbol ("SigButton");
+Tree sigButton (Tree lbl) { return tree(SIGBUTTON, lbl); }
+bool isSigButton (Tree s) { Tree lbl; return isTree(s, SIGBUTTON, lbl); }
+bool isSigButton (Tree s, Tree& lbl) { return isTree(s, SIGBUTTON, lbl); }
+
+
+Sym SIGCHECKBOX = symbol ("SigCheckbox");
+Tree sigCheckbox (Tree lbl) { return tree(SIGCHECKBOX, lbl); }
+bool isSigCheckbox (Tree s) { Tree lbl; return isTree(s, SIGCHECKBOX, lbl); }
+bool isSigCheckbox (Tree s, Tree& lbl) { return isTree(s, SIGCHECKBOX, lbl); }
+
+
+Sym SIGHSLIDER = symbol ("SigHSlider");
+Tree sigHSlider (Tree lbl, Tree cur, Tree min, Tree max, Tree step)
+ { return tree(SIGHSLIDER, lbl, list4(cur,min,max,step)); }
+bool isSigHSlider (Tree s) { Tree lbl, params; return isTree(s, SIGHSLIDER, lbl, params); }
+
+bool isSigHSlider (Tree s, Tree& lbl, Tree& cur, Tree& min, Tree& max, Tree& step)
+{
+ Tree params;
+ if (isTree(s, SIGHSLIDER, lbl, params)) {
+ cur = nth(params, 0);
+ min = nth(params, 1);
+ max = nth(params, 2);
+ step= nth(params, 3);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+
+Sym SIGVSLIDER = symbol ("SigVSlider");
+Tree sigVSlider (Tree lbl, Tree cur, Tree min, Tree max, Tree step)
+ { return tree(SIGVSLIDER, lbl, list4(cur,min,max,step)); }
+bool isSigVSlider (Tree s) { Tree lbl, params; return isTree(s, SIGVSLIDER, lbl, params); }
+
+bool isSigVSlider (Tree s, Tree& lbl, Tree& cur, Tree& min, Tree& max, Tree& step)
+{
+ Tree params;
+ if (isTree(s, SIGVSLIDER, lbl, params)) {
+ cur = nth(params, 0);
+ min = nth(params, 1);
+ max = nth(params, 2);
+ step= nth(params, 3);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+
+Sym SIGNUMENTRY = symbol ("SigNumEntry");
+Tree sigNumEntry (Tree lbl, Tree cur, Tree min, Tree max, Tree step)
+ { return tree(SIGNUMENTRY, lbl, list4(cur,min,max,step)); }
+bool isSigNumEntry (Tree s) { Tree lbl, params; return isTree(s, SIGNUMENTRY, lbl, params); }
+
+bool isSigNumEntry (Tree s, Tree& lbl, Tree& cur, Tree& min, Tree& max, Tree& step)
+{
+ Tree params;
+ if (isTree(s, SIGNUMENTRY, lbl, params)) {
+ cur = nth(params, 0);
+ min = nth(params, 1);
+ max = nth(params, 2);
+ step= nth(params, 3);
+ return true;
+ } else {
+ return false;
+ }
+}
+
+// output elements
+
+
+
+Sym SIGHBARGRAPH = symbol ("SigHBargraph");
+Tree sigHBargraph (Tree lbl, Tree min, Tree max, Tree x) { return tree(SIGHBARGRAPH, lbl, min, max, x); }
+bool isSigHBargraph (Tree s) { Tree lbl, min, max, x; return isTree(s, SIGHBARGRAPH, lbl, min, max, x); }
+bool isSigHBargraph (Tree s, Tree& lbl, Tree& min, Tree& max, Tree& x) { return isTree(s, SIGHBARGRAPH, lbl, min, max, x); }
+
+
+Sym SIGVBARGRAPH = symbol ("SigVBargraph");
+Tree sigVBargraph (Tree lbl, Tree min, Tree max, Tree x) { return tree(SIGVBARGRAPH, lbl, min, max, x); }
+bool isSigVBargraph (Tree s) { Tree lbl, min, max, x; return isTree(s, SIGVBARGRAPH, lbl, min, max, x); }
+bool isSigVBargraph (Tree s, Tree& lbl, Tree& min, Tree& max, Tree& x) { return isTree(s, SIGVBARGRAPH, lbl, min, max, x); }
+
+
+Sym SIGATTACH = symbol ("sigAttach");
+Tree sigAttach(Tree t0, Tree t1) { return tree(SIGATTACH, t0, t1); }
+bool isSigAttach(Tree t, Tree& t0, Tree& t1) { return isTree(t, SIGATTACH, t0, t1); }
+
+
+
+Tree addNums(Tree a, Tree b)
+{
+ Tree r = tree(addNode(a->node(),b->node()));
+ //cerr.flags(ios::showpoint); cerr << "addNums " << *a << "+" << *b << " -> " << *r << endl;
+ return r;
+}
+
+Tree subNums(Tree a, Tree b)
+{
+ Tree r = tree(subNode(a->node(),b->node()));
+ //cerr.flags(ios::showpoint); cerr << "subNums " << *a << "-" << *b << " -> " << *r << endl;
+ return r;
+}
+
+Tree mulNums(Tree a, Tree b)
+{
+ Tree r = tree(mulNode(a->node(),b->node()));
+ //cerr.flags(ios::showpoint); cerr << "mulNums " << *a << "*" << *b << " -> " << *r << endl;
+ return r;
+}
+
+Tree divNums(Tree a, Tree b)
+{
+ Tree r = tree(divNode(a->node(),b->node()));
+ //cerr.flags(ios::showpoint); cerr << "divNums " << *a << "/" << *b << " -> " << *r << endl;
+ return r;
+}
+
+Tree divExtendedNums(Tree a, Tree b)
+{
+ Tree r = tree(divExtendedNode(a->node(),b->node()));
+ //cerr.flags(ios::showpoint); cerr << "divExtendeNums " << *a << "/" << *b << " -> " << *r << endl;
+ return r;
+}
+
+Tree minusNum(Tree a)
+{
+ Tree r = tree(minusNode(a->node()));
+ //cerr.flags(ios::showpoint); cerr << "minusNum " << *a << " -> " << *r << endl;
+ return r;
+}
+
+Tree inverseNum(Tree a)
+{
+ Tree r = tree(inverseNode(a->node()));
+ //cerr.flags(ios::showpoint); cerr << "inverseNum " << *a << " -> " << *r << endl;
+ return r;
+}
+
+bool isSigAdd(Tree a, Tree& x, Tree& y)
+{
+ int op;
+ return isSigBinOp(a, &op, x, y) && (op == kAdd);
+}
+
+bool isSigMul(Tree a, Tree& x, Tree& y)
+{
+ int op;
+ return isSigBinOp(a, &op, x, y) && (op == kMul);
+}
+
+bool isSigSub(Tree a, Tree& x, Tree& y)
+{
+ int op;
+ return isSigBinOp(a, &op, x, y) && (op == kSub);
+}
+
+bool isSigDiv(Tree a, Tree& x, Tree& y)
+{
+ int op;
+ return isSigBinOp(a, &op, x, y) && (op == kDiv);
+}
+
+
+
+
+/*****************************************************************************
+ matrix extension
+*****************************************************************************/
+Sym SIGTUPLE = symbol ("SigTuple");
+Sym SIGTUPLEACCESS = symbol ("SigTupleAccess");
+
+// a tuple of signals is basically a list of signals.
+// mode = 0 means normal, mode = 1 means blocked
+Tree sigTuple (int mode, Tree ls) { return tree(SIGTUPLE, tree(mode), ls); }
+bool isSigTuple (Tree s, int* mode, Tree& ls) { Tree m; return isTree(s, SIGTUPLE, m, ls) && isInt(m->node(), mode); }
+
+// Access the components of a tuple.
+// ts is tuple of signals, idx is a scalar signal between 0..n
+Tree sigTupleAccess(Tree ts, Tree idx) { return tree(SIGTUPLEACCESS, ts, idx); }
+bool isSigTupleAccess(Tree s, Tree& ts, Tree& idx) { return isTree(s, SIGTUPLEACCESS, ts, idx); }
+
+// create a tuple of signals
+Tree sigCartesianProd (Tree s1, Tree s2)
+{
+ Tree l1, l2;
+ int m1, m2;
+
+ if (isSigTuple(s1, &m1, l1) && (m1 == 0)) {
+ // nothing to do
+ } else {
+ l1 = list1(s1);
+ }
+
+ if (isSigTuple(s2, &m2, l2) && (m2 == 0)) {
+ // nothing to do
+ } else {
+ l2 = list1(s2);
+ }
+
+
+ return sigTuple(0, concat(l1,l2));
+}
+
+
+
+/**
+ * Test if exp is very simple that is it
+ * can't be considered a real component
+ * @param exp the signal we want to test
+ * @return true if it a very simple signal
+ */
+bool verySimple(Tree exp)
+{
+ int i;
+ double r;
+ Tree type, name, file;
+
+ return isSigInt(exp, &i)
+ || isSigReal(exp, &r)
+ || isSigInput(exp, &i)
+ || isSigFConst(exp, type, name, file);
+}
projects / Faustine.git / blobdiff