+++ /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.
- ************************************************************************
- ************************************************************************/
-
-
-
-#include <stdio.h>
-#include <assert.h>
-#include "list.hh"
-#include "signals.hh"
-#include "sigtype.hh"
-#include "recursivness.hh"
-#include "sigtyperules.hh"
-#include "sigorderrules.hh"
-#include "sigprint.hh"
-#include "ppsig.hh"
-#include "simplify.hh"
-#include "num.hh"
-#include "xtended.hh"
-#include <map>
-#include "compatibility.hh"
-
-#include "normalize.hh"
-
-#undef TRACE
-
-// declarations
-Tree SIMPLIFIED = tree(symbol("sigSimplifiedProp"));
-//static Tree binequiv (Tree sig, int opnum, Tree a, Tree b);
-static Tree simplification (Tree sig);
-static Tree sigMap (Tree key, tfun f, Tree t);
-
-static Tree traced_simplification(Tree sig)
-{
- assert(sig);
-#ifdef TRACE
- cerr << ++TABBER << "Start simplification of : " << ppsig(sig) << endl;
- /*
- fprintf(stderr, "\nStart simplification of : ");
- printSignal(sig, stderr);
- fprintf(stderr, "\n");
- */
-#endif
- Tree r = simplification(sig);
- assert(r!=0);
-#ifdef TRACE
- cerr << --TABBER << "Simplification of : " << ppsig(sig) << " Returns : " << ppsig(r) << endl;
- /*
- fprintf(stderr, "Simplification of : ");
- printSignal(sig, stderr);
- fprintf(stderr, " -> ");
- printSignal(r, stderr);
- fprintf(stderr, "\n");
- */
-#endif
- return r;
-}
-
-Tree simplify (Tree sig)
-{
- return sigMap(SIMPLIFIED, traced_simplification, sig);
-}
-
-
-// Implementation
-
-static Tree simplification (Tree sig)
-{
- assert(sig);
- int opnum;
- Tree t1, t2, t3, t4;
-
- xtended* xt = (xtended*) getUserData(sig);
- // primitive elements
- if (xt)
- {
- //return 3;
- vector<Tree> args;
- for (int i=0; i<sig->arity(); i++) { args.push_back( sig->branch(i) ); }
-
- // to avoid negative power to further normalization
- if (xt != gPowPrim) {
- return xt->computeSigOutput(args);
- } else {
- return normalizeAddTerm(xt->computeSigOutput(args));
- }
-
- } else if (isSigBinOp(sig, &opnum, t1, t2)) {
-
- BinOp* op = gBinOpTable[opnum];
-
- Node n1 = t1->node();
- Node n2 = t2->node();
-
- if (isNum(n1) && isNum(n2)) return tree(op->compute(n1,n2));
-
- else if (op->isLeftNeutral(n1)) return t2;
-
- else if (op->isRightNeutral(n2)) return t1;
-
- else return normalizeAddTerm(sig);
-
- } else if (isSigDelay1(sig, t1)) {
-
- return normalizeDelay1Term (t1);
-
- } else if (isSigFixDelay(sig, t1, t2)) {
-
- return normalizeFixedDelayTerm (t1, t2);
-
- } else if (isSigIntCast(sig, t1)) {
-
- Tree tx;
- int i;
- double x;
- Node n1 = t1->node();
-
- if (isInt(n1, &i)) return t1;
- if (isDouble(n1, &x)) return tree(int(x));
- if (isSigIntCast(t1, tx)) return t1;
-
- return sig;
-
- } else if (isSigFloatCast(sig, t1)) {
-
- Tree tx;
- int i;
- double x;
- Node n1 = t1->node();
-
- if (isInt(n1, &i)) return tree(double(i));
- if (isDouble(n1, &x)) return t1;
- if (isSigFloatCast(t1, tx)) return t1;
-
- return sig;
-
- } else if (isSigSelect2(sig, t1, t2, t3)){
-
- Node n1 = t1->node();
-
- if (isZero(n1)) return t2;
- if (isNum(n1)) return t3;
-
- if (t2==t3) return t2;
-
- return sig;
-
- } else if (isSigSelect3(sig, t1, t2, t3, t4)){
-
- Node n1 = t1->node();
-
- if (isZero(n1)) return t2;
- if (isOne(n1)) return t3;
- if (isNum(n1)) return t4;
-
- if (t3==t4) return simplification(sigSelect2(t1,t2,t3));
-
- return sig;
-
- } else {
-
- return sig;
- }
-}
-
-/**
- * Recursively transform a graph by applying a function f.
- * map(f, foo[t1..tn]) = f(foo[map(f,t1)..map(f,tn)])
- */
-static Tree sigMap (Tree key, tfun f, Tree t)
-{
- //printf("start sigMap\n");
- Tree p,id,body;
-
- if (getProperty(t, key, p)) {
-
- return (isNil(p)) ? t : p; // truc pour eviter les boucles
-
- } else if (isRec(t, id, body)) {
-
- setProperty(t, key, nil); // avoid infinite loop
- return rec(id, sigMap(key, f, body));
-
- } else {
-
- Tree r1=nil;
- switch (t->arity()) {
-
- case 0 :
- r1 = t;
- break;
- case 1 :
- r1 = tree(t->node(), sigMap(key,f,t->branch(0)));
- break;
- case 2 :
- r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)));
- break;
- case 3 :
- r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
- sigMap(key,f,t->branch(2)));
- break;
- case 4 :
- r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
- sigMap(key,f,t->branch(2)), sigMap(key,f,t->branch(3)));
- break;
- }
- Tree r2 = f(r1);
- if (r2 == t) {
- setProperty(t, key, nil);
- } else {
- setProperty(t, key, r2);
- }
- return r2;
- }
-}
-
-
-
-
-
-/**
- * Like SigMap, recursively transform a graph by applying a
- * function f. But here recursive trees are also renamed.
- * map(f, foo[t1..tn]) = f(foo[map(f,t1)..map(f,tn)])
- */
-static Tree sigMapRename (Tree key, Tree env, tfun f, Tree t)
-{
- //printf("start sigMap\n");
- Tree p,id,body;
-
- if (getProperty(t, key, p)) {
-
- return (isNil(p)) ? t : p; // truc pour eviter les boucles
-
- } else if (isRec(t, id, body)) {
-
- assert(isRef(t,id)); // controle temporaire
-
- Tree id2;
- if (searchEnv(id, id2, env)) {
- // déjà en cours de visite de cette recursion
- return ref(id2);
- } else {
- // premiere visite de cette recursion
- id2 = tree(Node(unique("renamed")));
- Tree body2 = sigMapRename(key, pushEnv(id, id2, env), f, body);
- return rec(id2,body2);
- }
-
- } else {
-
- Tree r1=nil;
- switch (t->arity()) {
-
- case 0 :
- r1 = t;
- break;
- case 1 :
- r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)));
- break;
- case 2 :
- r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
- sigMapRename(key,env,f,t->branch(1)));
- break;
- case 3 :
- r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
- sigMapRename(key,env,f,t->branch(1)),
- sigMapRename(key,env,f,t->branch(2)));
- break;
- case 4 :
- r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
- sigMapRename(key,env,f,t->branch(1)),
- sigMapRename(key,env,f,t->branch(2)),
- sigMapRename(key,env,f,t->branch(3)));
- break;
- }
- Tree r2 = f(r1);
- if (r2 == t) {
- setProperty(t, key, nil);
- } else {
- setProperty(t, key, r2);
- }
- return r2;
- }
-}
-
-#if 0
-static void eraseProperties (Tree key, Tree t)
-{
- //printf("start sigMap\n");
- Tree p,id,body;
-
- if (getProperty(t, key, p)) {
- // already erased, nothing to do
-
- } else if (isRec(t, id, body)) {
- t->clearProperties();
- Tree r=rec(id, body);
- assert(r==t);
- setProperty(t, key, nil); // avoid infinite loop
- eraseProperties(key, body);
-
- } else {
-
- for (int i=0; i<t->arity(); i++) {
- eraseProperties(key,t->branch(i));
- }
- }
-}
-
-void eraseAllProperties(Tree t)
-{
- cerr << "begin eraseAllProperties" << endl;
- eraseProperties(tree(Node(unique("erase_"))), t);
- cerr << "end eraseAllProperties" << endl;
-}
-#endif
-
-/**
- * Converts regular tables into doc tables in order to
- * facilitate the mathematical documentation generation
- */
-
-Tree DOCTABLES = tree(symbol("DocTablesProp"));
-
-static Tree docTableConverter (Tree sig);
-
-static Tree NULLENV = tree(symbol("NullRenameEnv"));
-
-Tree docTableConvertion (Tree sig)
-{
- Tree r = sigMapRename(DOCTABLES, NULLENV, docTableConverter, sig);
- return r;
-}
-
-
-// Implementation
-
-static Tree docTableConverter (Tree sig)
-{
- Tree tbl, tbl2, id, id2, size, igen, isig, ridx, widx, wsig;
-
- if (isSigRDTbl(sig, tbl, ridx)) {
- // we are in a table to convert
- if (isSigTable(tbl, id, size, igen)) {
- // it's a read only table
- assert(isSigGen(igen, isig));
- return sigDocAccessTbl(sigDocConstantTbl(size,isig),ridx);
- } else {
- // it's a read write table
- assert(isSigWRTbl(tbl,id,tbl2,widx,wsig));
- assert(isSigTable(tbl2, id2, size, igen));
- assert(isSigGen(igen, isig));
-
- return sigDocAccessTbl(sigDocWriteTbl(size,isig,widx,wsig),ridx);
- }
-
- } else {
- // nothing to convert
- return sig;
- }
-}
projects / Faustine.git / blobdiff