First cleaning step in "dsp_files" directory.
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / headers / signals.hh
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #ifndef _SIGNALS_
25 #define _SIGNALS_
26
27 #include "tlib.hh"
28 #include "binop.hh"
29 #include <assert.h>
30 #include <vector>
31
32 using namespace std;
33
34
35 ////////////////////////////////////////////////////////////////////////
36 /**
37 * Signals
38 * Block-diagrams are converted into signal expressions via
39 * symbolic propagation
40 */
41 ///////////////////////////////////////////////////////////////////////
42
43 // Constant signals : for all t, x(t)=n
44 Tree sigInt(int n);
45 Tree sigReal(double n);
46
47 bool isSigInt(Tree t, int* i);
48 bool isSigReal(Tree t, double* r);
49
50
51 // Inputs and outputs
52 Tree sigInput(int i);
53 Tree sigOutput(int i, Tree t);
54
55 bool isSigInput(Tree t, int* i);
56 bool isSigOutput(Tree t, int* i, Tree& t0);
57
58 // delay
59 Tree sigDelay0(Tree t);
60 Tree sigDelay1(Tree t);
61 bool isSigDelay1(Tree t, Tree& t0);
62
63 Tree sigFixDelay(Tree t0, Tree t1);
64 bool isSigFixDelay(Tree t, Tree& t0, Tree& t1);
65
66 Tree sigPrefix(Tree t0, Tree t1);
67 bool isSigPrefix(Tree t, Tree& t0, Tree& t1);
68
69 Tree sigIota(Tree t0);
70 bool isSigIota(Tree t, Tree& t0);
71
72 // Int and Double casting
73 Tree sigIntCast(Tree t);
74 Tree sigFloatCast(Tree t);
75
76 bool isSigIntCast(Tree t);
77 bool isSigFloatCast(Tree t);
78
79 bool isSigIntCast(Tree t, Tree& x);
80 bool isSigFloatCast(Tree t, Tree& x);
81
82
83 // tables
84 Tree sigRDTbl (Tree t, Tree i);
85 Tree sigWRTbl (Tree id, Tree t, Tree i, Tree s);
86 Tree sigTable (Tree id, Tree n, Tree sig);
87 Tree sigGen (Tree content);
88
89 bool isSigRDTbl (Tree s, Tree& t, Tree& i);
90 bool isSigWRTbl (Tree u, Tree& id, Tree& t, Tree& i, Tree& s);
91 bool isSigTable (Tree t, Tree& id, Tree& n, Tree& sig);
92 bool isSigGen (Tree t, Tree& content);
93 bool isSigGen (Tree t);
94
95 inline Tree sigWriteReadTable(Tree n, Tree init, Tree widx, Tree wsig, Tree ridx)
96 {
97 return sigRDTbl(sigWRTbl(nil, sigTable(nil, n, sigGen(init)), widx, wsig), ridx);
98 }
99
100 inline Tree sigReadOnlyTable(Tree n, Tree init, Tree ridx)
101 {
102 return sigRDTbl(sigTable(nil, n, sigGen(init)), ridx);
103 }
104
105
106 // Tables for documentator
107 // used to replace real tables for documentation purposes only
108
109 Tree sigDocConstantTbl(Tree n, Tree init);
110 Tree sigDocWriteTbl(Tree n, Tree init, Tree widx, Tree wsig);
111 Tree sigDocAccessTbl(Tree doctbl, Tree ridx);
112
113 bool isSigDocConstantTbl(Tree s, Tree& n, Tree& init);
114 bool isSigDocWriteTbl(Tree s, Tree& n, Tree& init, Tree& widx, Tree& wsig);
115 bool isSigDocAccessTbl(Tree s, Tree& doctbl, Tree& ridx);
116
117 // selectors
118
119 Tree sigSelect2 (Tree selector, Tree s1, Tree s2);
120 Tree sigSelect3 (Tree selector, Tree s1, Tree s2, Tree s3);
121
122 bool isSigSelect2 (Tree t, Tree& selector, Tree& s1, Tree& s2);
123 bool isSigSelect3 (Tree t, Tree& selector, Tree& s1, Tree& s2, Tree& s3);
124
125
126 // multirate
127 Tree sigVectorize (Tree n, Tree s);
128 bool isSigVectorize (Tree a, Tree& n, Tree& s);
129
130 Tree sigSerialize (Tree s);
131 bool isSigSerialize (Tree a, Tree& s);
132
133 Tree sigConcat (Tree s1, Tree s2);
134 bool isSigConcat (Tree a, Tree& s1, Tree& s2);
135
136 Tree sigVectorAt (Tree s1, Tree s2);
137 bool isSigVectorAt (Tree a, Tree& s1, Tree& s2);
138
139 Tree sigUpSample (Tree n, Tree s);
140 bool isSigUpSample (Tree a, Tree& n, Tree& s);
141
142 Tree sigDownSample (Tree n, Tree s);
143 bool isSigDownSample (Tree a, Tree& n, Tree& s);
144
145
146 // arithmetical operations
147
148 Tree sigBinOp (int op, Tree x, Tree y);
149 bool isSigBinOp (Tree s, int* op, Tree& x, Tree& y);
150
151 // Foreign Functions
152
153 Tree sigFFun (Tree ff, Tree largs);
154 bool isSigFFun (Tree s, Tree& ff, Tree& largs);
155
156 // Foreign Constants
157
158 Tree sigFConst (Tree type, Tree name, Tree file);
159 bool isSigFConst (Tree s);
160 bool isSigFConst (Tree s, Tree& type, Tree& name, Tree& file);
161
162 // Foreign Variables
163
164 Tree sigFVar (Tree type, Tree name, Tree file);
165 bool isSigFVar (Tree s);
166 bool isSigFVar (Tree s, Tree& type, Tree& name, Tree& file);
167
168 // emulation des anciennes fonctions
169 inline Tree sigAdd(Tree x, Tree y) { return sigBinOp(kAdd, x, y); }
170 inline Tree sigSub(Tree x, Tree y) { return sigBinOp(kSub, x, y); }
171 inline Tree sigMul(Tree x, Tree y) { return sigBinOp(kMul, x, y); }
172 inline Tree sigDiv(Tree x, Tree y) { return sigBinOp(kDiv, x, y); }
173 inline Tree sigRem(Tree x, Tree y) { return sigBinOp(kRem, x, y); }
174
175 inline Tree sigAND(Tree x, Tree y) { return sigBinOp(kAND, x, y); }
176 inline Tree sigOR(Tree x, Tree y) { return sigBinOp(kOR, x, y); }
177 inline Tree sigXOR(Tree x, Tree y) { return sigBinOp(kXOR, x, y); }
178
179 inline Tree sigLeftShift(Tree x, Tree y) { return sigBinOp(kLsh, x, y); }
180 inline Tree sigRightShift(Tree x, Tree y) { return sigBinOp(kRsh, x, y); }
181
182 inline Tree sigGT(Tree x, Tree y) { return sigBinOp(kGT, x, y); }
183 inline Tree sigLT(Tree x, Tree y) { return sigBinOp(kLT, x, y); }
184 inline Tree sigGE(Tree x, Tree y) { return sigBinOp(kGE, x, y); }
185 inline Tree sigLE(Tree x, Tree y) { return sigBinOp(kLE, x, y); }
186 inline Tree sigEQ(Tree x, Tree y) { return sigBinOp(kEQ, x, y); }
187 inline Tree sigNE(Tree x, Tree y) { return sigBinOp(kNE, x, y); }
188
189 // pattern matching pour les anciennes fonctions
190 bool isSigAdd (Tree a, Tree&x, Tree&y);
191 bool isSigMul (Tree a, Tree&x, Tree&y);
192 bool isSigSub (Tree a, Tree&x, Tree&y);
193 bool isSigDiv (Tree a, Tree&x, Tree&y);
194
195 // operations pratiques sur des arbres dont on sait qu'ils sont des nombres
196 Tree addNums (Tree a, Tree b);
197 Tree subNums (Tree a, Tree b);
198 Tree mulNums (Tree a, Tree b);
199 Tree divNums (Tree a, Tree b);
200 Tree divExtendedNums (Tree a, Tree b);
201 Tree minusNum (Tree a);
202 Tree inverseNum (Tree a);
203
204 // tests sur les signaux constants
205 inline bool isNum (Tree a) { assert(a); return isNum(a->node()); }
206 inline bool isZero (Tree a) { assert(a); return isZero(a->node()); }
207 inline bool isGTZero (Tree a) { assert(a); return isGTZero(a->node()); }
208 inline bool isGEZero (Tree a) { assert(a); return isGEZero(a->node()); }
209 inline bool isOne (Tree a) { assert(a); return isOne(a->node()); }
210 inline bool isMinusOne (Tree a) { assert(a); return isMinusOne(a->node()); }
211
212 //projection for recursive groups
213 Tree sigProj (int i, Tree rgroup);
214 bool isProj (Tree t, int* i, Tree& rgroup);
215
216 inline bool isNum(const Tree& t, num& n)
217 {
218 double f;
219 int i;
220
221 if (isDouble(t->node(), &f)) { n = f; return true; }
222 if (isInt(t->node(), &i)) { n = i; return true; }
223 return false;
224 }
225
226
227 /*****************************************************************************
228 User Interface Elements
229 *****************************************************************************/
230
231 Tree sigButton (Tree label);
232 bool isSigButton (Tree s);
233 bool isSigButton (Tree s, Tree& label);
234
235 Tree sigCheckbox (Tree label);
236 bool isSigCheckbox (Tree s);
237 bool isSigCheckbox (Tree s, Tree& label);
238
239 Tree sigVSlider (Tree label, Tree cur, Tree min, Tree max, Tree step);
240 bool isSigVSlider (Tree s);
241 bool isSigVSlider (Tree s, Tree& label, Tree& cur, Tree& min, Tree& max, Tree& step);
242
243 Tree sigHSlider (Tree label, Tree cur, Tree min, Tree max, Tree step);
244 bool isSigHSlider (Tree s);
245 bool isSigHSlider (Tree s, Tree& label, Tree& cur, Tree& min, Tree& max, Tree& step);
246
247 Tree sigNumEntry (Tree label, Tree cur, Tree min, Tree max, Tree step);
248 bool isSigNumEntry (Tree s);
249 bool isSigNumEntry (Tree s, Tree& label, Tree& cur, Tree& min, Tree& max, Tree& step);
250
251 // output elements
252 Tree sigVBargraph (Tree label, Tree min, Tree max, Tree t0);
253 bool isSigVBargraph (Tree s);
254 bool isSigVBargraph (Tree s, Tree& label, Tree& min, Tree& max, Tree& t0);
255
256 Tree sigHBargraph (Tree label, Tree min, Tree max, Tree t0);
257 bool isSigHBargraph (Tree s);
258 bool isSigHBargraph (Tree s, Tree& label, Tree& min, Tree& max, Tree& t0);
259
260 Tree sigAttach (Tree x, Tree y);
261 bool isSigAttach (Tree s);
262 bool isSigAttach (Tree s, Tree& x, Tree& y);
263
264
265 /*****************************************************************************
266 matrix extension
267 *****************************************************************************/
268
269 // a tuple of signals is basically a list of signals.
270 // mode = 0 means normal, mode = 1 means blocked
271 Tree sigTuple (int mode, Tree ls);
272 bool isSigTuple (Tree s, int* mode, Tree& ls);
273
274 // Access the components of a tuple.
275 // ts is tuple of signals, idx is a scalar signal between 0..n
276 Tree sigTupleAccess(Tree ts, Tree idx);
277 bool isSigTupleAccess(Tree s, Tree& ts, Tree& idx);
278
279 // create a tuple of signals
280 Tree sigCartesianProd (Tree s1, Tree s2);
281
282
283
284 /*****************************************************************************
285 access to sub signals of a signal
286 *****************************************************************************/
287
288 int getSubSignals (Tree sig, vector<Tree>& vsigs, bool visitgen=true);
289
290
291 /**
292 * Test if exp is very simple that is it
293 * can't be considered a real component
294 * @param exp the signal we want to test
295 * @return true if it a very simple signal
296 */
297 bool verySimple(Tree exp);
298
299
300
301 #endif