Recompile and test of the master branch.
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / normalize / simplify.cpp
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 #include <stdio.h>
25 #include <assert.h>
26 #include "list.hh"
27 #include "signals.hh"
28 #include "sigtype.hh"
29 #include "recursivness.hh"
30 #include "sigtyperules.hh"
31 #include "sigorderrules.hh"
32 #include "sigprint.hh"
33 #include "ppsig.hh"
34 #include "simplify.hh"
35 #include "num.hh"
36 #include "xtended.hh"
37 #include <map>
38 #include "compatibility.hh"
39
40 #include "normalize.hh"
41
42 #undef TRACE
43
44 // declarations
45 Tree SIMPLIFIED = tree(symbol("sigSimplifiedProp"));
46 //static Tree binequiv (Tree sig, int opnum, Tree a, Tree b);
47 static Tree simplification (Tree sig);
48 static Tree sigMap (Tree key, tfun f, Tree t);
49
50 static Tree traced_simplification(Tree sig)
51 {
52 assert(sig);
53 #ifdef TRACE
54 cerr << ++TABBER << "Start simplification of : " << ppsig(sig) << endl;
55 /*
56 fprintf(stderr, "\nStart simplification of : ");
57 printSignal(sig, stderr);
58 fprintf(stderr, "\n");
59 */
60 #endif
61 Tree r = simplification(sig);
62 assert(r!=0);
63 #ifdef TRACE
64 cerr << --TABBER << "Simplification of : " << ppsig(sig) << " Returns : " << ppsig(r) << endl;
65 /*
66 fprintf(stderr, "Simplification of : ");
67 printSignal(sig, stderr);
68 fprintf(stderr, " -> ");
69 printSignal(r, stderr);
70 fprintf(stderr, "\n");
71 */
72 #endif
73 return r;
74 }
75
76 Tree simplify (Tree sig)
77 {
78 return sigMap(SIMPLIFIED, traced_simplification, sig);
79 }
80
81
82 // Implementation
83
84 static Tree simplification (Tree sig)
85 {
86 assert(sig);
87 int opnum;
88 Tree t1, t2, t3, t4;
89
90 xtended* xt = (xtended*) getUserData(sig);
91 // primitive elements
92 if (xt)
93 {
94 //return 3;
95 vector<Tree> args;
96 for (int i=0; i<sig->arity(); i++) { args.push_back( sig->branch(i) ); }
97
98 // to avoid negative power to further normalization
99 if (xt != gPowPrim) {
100 return xt->computeSigOutput(args);
101 } else {
102 return normalizeAddTerm(xt->computeSigOutput(args));
103 }
104
105 } else if (isSigBinOp(sig, &opnum, t1, t2)) {
106
107 BinOp* op = gBinOpTable[opnum];
108
109 Node n1 = t1->node();
110 Node n2 = t2->node();
111
112 if (isNum(n1) && isNum(n2)) return tree(op->compute(n1,n2));
113
114 else if (op->isLeftNeutral(n1)) return t2;
115
116 else if (op->isRightNeutral(n2)) return t1;
117
118 else return normalizeAddTerm(sig);
119
120 } else if (isSigDelay1(sig, t1)) {
121
122 return normalizeDelay1Term (t1);
123
124 } else if (isSigFixDelay(sig, t1, t2)) {
125
126 return normalizeFixedDelayTerm (t1, t2);
127
128 } else if (isSigIntCast(sig, t1)) {
129
130 Tree tx;
131 int i;
132 double x;
133 Node n1 = t1->node();
134
135 if (isInt(n1, &i)) return t1;
136 if (isDouble(n1, &x)) return tree(int(x));
137 if (isSigIntCast(t1, tx)) return t1;
138
139 return sig;
140
141 } else if (isSigFloatCast(sig, t1)) {
142
143 Tree tx;
144 int i;
145 double x;
146 Node n1 = t1->node();
147
148 if (isInt(n1, &i)) return tree(double(i));
149 if (isDouble(n1, &x)) return t1;
150 if (isSigFloatCast(t1, tx)) return t1;
151
152 return sig;
153
154 } else if (isSigSelect2(sig, t1, t2, t3)){
155
156 Node n1 = t1->node();
157
158 if (isZero(n1)) return t2;
159 if (isNum(n1)) return t3;
160
161 if (t2==t3) return t2;
162
163 return sig;
164
165 } else if (isSigSelect3(sig, t1, t2, t3, t4)){
166
167 Node n1 = t1->node();
168
169 if (isZero(n1)) return t2;
170 if (isOne(n1)) return t3;
171 if (isNum(n1)) return t4;
172
173 if (t3==t4) return simplification(sigSelect2(t1,t2,t3));
174
175 return sig;
176
177 } else {
178
179 return sig;
180 }
181 }
182
183 /**
184 * Recursively transform a graph by applying a function f.
185 * map(f, foo[t1..tn]) = f(foo[map(f,t1)..map(f,tn)])
186 */
187 static Tree sigMap (Tree key, tfun f, Tree t)
188 {
189 //printf("start sigMap\n");
190 Tree p,id,body;
191
192 if (getProperty(t, key, p)) {
193
194 return (isNil(p)) ? t : p; // truc pour eviter les boucles
195
196 } else if (isRec(t, id, body)) {
197
198 setProperty(t, key, nil); // avoid infinite loop
199 return rec(id, sigMap(key, f, body));
200
201 } else {
202
203 Tree r1=nil;
204 switch (t->arity()) {
205
206 case 0 :
207 r1 = t;
208 break;
209 case 1 :
210 r1 = tree(t->node(), sigMap(key,f,t->branch(0)));
211 break;
212 case 2 :
213 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)));
214 break;
215 case 3 :
216 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
217 sigMap(key,f,t->branch(2)));
218 break;
219 case 4 :
220 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
221 sigMap(key,f,t->branch(2)), sigMap(key,f,t->branch(3)));
222 break;
223 }
224 Tree r2 = f(r1);
225 if (r2 == t) {
226 setProperty(t, key, nil);
227 } else {
228 setProperty(t, key, r2);
229 }
230 return r2;
231 }
232 }
233
234
235
236
237
238 /**
239 * Like SigMap, recursively transform a graph by applying a
240 * function f. But here recursive trees are also renamed.
241 * map(f, foo[t1..tn]) = f(foo[map(f,t1)..map(f,tn)])
242 */
243 static Tree sigMapRename (Tree key, Tree env, tfun f, Tree t)
244 {
245 //printf("start sigMap\n");
246 Tree p,id,body;
247
248 if (getProperty(t, key, p)) {
249
250 return (isNil(p)) ? t : p; // truc pour eviter les boucles
251
252 } else if (isRec(t, id, body)) {
253
254 assert(isRef(t,id)); // controle temporaire
255
256 Tree id2;
257 if (searchEnv(id, id2, env)) {
258 // déjà en cours de visite de cette recursion
259 return ref(id2);
260 } else {
261 // premiere visite de cette recursion
262 id2 = tree(Node(unique("renamed")));
263 Tree body2 = sigMapRename(key, pushEnv(id, id2, env), f, body);
264 return rec(id2,body2);
265 }
266
267 } else {
268
269 Tree r1=nil;
270 switch (t->arity()) {
271
272 case 0 :
273 r1 = t;
274 break;
275 case 1 :
276 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)));
277 break;
278 case 2 :
279 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
280 sigMapRename(key,env,f,t->branch(1)));
281 break;
282 case 3 :
283 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
284 sigMapRename(key,env,f,t->branch(1)),
285 sigMapRename(key,env,f,t->branch(2)));
286 break;
287 case 4 :
288 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
289 sigMapRename(key,env,f,t->branch(1)),
290 sigMapRename(key,env,f,t->branch(2)),
291 sigMapRename(key,env,f,t->branch(3)));
292 break;
293 }
294 Tree r2 = f(r1);
295 if (r2 == t) {
296 setProperty(t, key, nil);
297 } else {
298 setProperty(t, key, r2);
299 }
300 return r2;
301 }
302 }
303
304 #if 0
305 static void eraseProperties (Tree key, Tree t)
306 {
307 //printf("start sigMap\n");
308 Tree p,id,body;
309
310 if (getProperty(t, key, p)) {
311 // already erased, nothing to do
312
313 } else if (isRec(t, id, body)) {
314 t->clearProperties();
315 Tree r=rec(id, body);
316 assert(r==t);
317 setProperty(t, key, nil); // avoid infinite loop
318 eraseProperties(key, body);
319
320 } else {
321
322 for (int i=0; i<t->arity(); i++) {
323 eraseProperties(key,t->branch(i));
324 }
325 }
326 }
327
328 void eraseAllProperties(Tree t)
329 {
330 cerr << "begin eraseAllProperties" << endl;
331 eraseProperties(tree(Node(unique("erase_"))), t);
332 cerr << "end eraseAllProperties" << endl;
333 }
334 #endif
335
336 /**
337 * Converts regular tables into doc tables in order to
338 * facilitate the mathematical documentation generation
339 */
340
341 Tree DOCTABLES = tree(symbol("DocTablesProp"));
342
343 static Tree docTableConverter (Tree sig);
344
345 static Tree NULLENV = tree(symbol("NullRenameEnv"));
346
347 Tree docTableConvertion (Tree sig)
348 {
349 Tree r = sigMapRename(DOCTABLES, NULLENV, docTableConverter, sig);
350 return r;
351 }
352
353
354 // Implementation
355
356 static Tree docTableConverter (Tree sig)
357 {
358 Tree tbl, tbl2, id, id2, size, igen, isig, ridx, widx, wsig;
359
360 if (isSigRDTbl(sig, tbl, ridx)) {
361 // we are in a table to convert
362 if (isSigTable(tbl, id, size, igen)) {
363 // it's a read only table
364 assert(isSigGen(igen, isig));
365 return sigDocAccessTbl(sigDocConstantTbl(size,isig),ridx);
366 } else {
367 // it's a read write table
368 assert(isSigWRTbl(tbl,id,tbl2,widx,wsig));
369 assert(isSigTable(tbl2, id2, size, igen));
370 assert(isSigGen(igen, isig));
371
372 return sigDocAccessTbl(sigDocWriteTbl(size,isig,widx,wsig),ridx);
373 }
374
375 } else {
376 // nothing to convert
377 return sig;
378 }
379 }