00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <stdio.h>
00025 #include <assert.h>
00026 #include "list.hh"
00027 #include "signals.hh"
00028 #include "sigtype.hh"
00029 #include "recursivness.hh"
00030 #include "sigtyperules.hh"
00031 #include "sigorderrules.hh"
00032 #include "sigprint.hh"
00033 #include "simplify.hh"
00034 #include "num.hh"
00035 #include "xtended.hh"
00036 #include <map>
00037 #include "compatibility.hh"
00038
00039 #include "normalize.hh"
00040
00041 #undef TRACE
00042
00043
00044 Tree SIMPLIFIED = tree(symbol("sigSimplifiedProp"));
00045
00046 static Tree simplification (Tree sig);
00047 static Tree sigMap (Tree key, tfun f, Tree t);
00048
00049 static Tree traced_simplification(Tree sig)
00050 {
00051 assert(sig);
00052 #ifdef TRACE
00053 cerr << ++TABBER << "Start simplification of : " << *sig << endl;
00054
00055
00056
00057
00058
00059 #endif
00060 Tree r = simplification(sig);
00061 assert(r!=0);
00062 #ifdef TRACE
00063 cerr << --TABBER << "Simplification of : " << *sig << " Returns : " << *r << endl;
00064
00065
00066
00067
00068
00069
00070
00071 #endif
00072 return r;
00073 }
00074
00075 Tree simplify (Tree sig)
00076 {
00077 return sigMap(SIMPLIFIED, traced_simplification, sig);
00078 }
00079
00080
00081
00082
00083 static Tree simplification (Tree sig)
00084 {
00085 assert(sig);
00086 int opnum;
00087 Tree t1, t2;
00088
00089 xtended* xt = (xtended*) getUserData(sig);
00090
00091 if (xt)
00092 {
00093
00094 vector<Tree> args;
00095 for (int i=0; i<sig->arity(); i++) { args.push_back( sig->branch(i) ); }
00096 return xt->computeSigOutput(args);
00097
00098 } else if (isSigBinOp(sig, &opnum, t1, t2)) {
00099
00100 BinOp* op = gBinOpTable[opnum];
00101
00102 Node n1 = t1->node();
00103 Node n2 = t2->node();
00104
00105 if (isNum(n1) && isNum(n2)) return tree(op->compute(n1,n2));
00106
00107 else if (op->isLeftNeutral(n1)) return t2;
00108
00109 else if (op->isRightNeutral(n2)) return t1;
00110
00111 else return normalizeAddTerm(sig);
00112
00113 } else if (isSigDelay1(sig, t1)) {
00114
00115 return normalizeDelay1Term (t1);
00116
00117 } else if (isSigFixDelay(sig, t1, t2)) {
00118
00119 return normalizeFixedDelayTerm (t1, t2);
00120
00121 } else if (isSigIntCast(sig, t1)) {
00122
00123 Tree tx;
00124 int i;
00125 double x;
00126 Node n1 = t1->node();
00127
00128 if (isInt(n1, &i)) return t1;
00129 if (isDouble(n1, &x)) return tree(int(x));
00130 if (isSigIntCast(t1, tx)) return t1;
00131
00132 return sig;
00133
00134 } else if (isSigFloatCast(sig, t1)) {
00135
00136 Tree tx;
00137 int i;
00138 double x;
00139 Node n1 = t1->node();
00140
00141 if (isInt(n1, &i)) return tree(double(i));
00142 if (isDouble(n1, &x)) return t1;
00143 if (isSigFloatCast(t1, tx)) return t1;
00144
00145 return sig;
00146
00147 } else {
00148
00149 return sig;
00150 }
00151 }
00152
00153
00154
00159 static Tree sigMap (Tree key, tfun f, Tree t)
00160 {
00161
00162 Tree p,id,body;
00163
00164 if (getProperty(t, key, p)) {
00165
00166 return (isNil(p)) ? t : p;
00167
00168 } else if (isRec(t, id, body)) {
00169
00170 setProperty(t, key, nil);
00171 return rec(id, sigMap(key, f, body));
00172
00173 } else {
00174
00175 Tree r1=nil;
00176 switch (t->arity()) {
00177
00178 case 0 :
00179 r1 = t;
00180 break;
00181 case 1 :
00182 r1 = tree(t->node(), sigMap(key,f,t->branch(0)));
00183 break;
00184 case 2 :
00185 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)));
00186 break;
00187 case 3 :
00188 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
00189 sigMap(key,f,t->branch(2)));
00190 break;
00191 case 4 :
00192 r1 = tree(t->node(), sigMap(key,f,t->branch(0)), sigMap(key,f,t->branch(1)),
00193 sigMap(key,f,t->branch(2)), sigMap(key,f,t->branch(3)));
00194 break;
00195 }
00196 Tree r2 = f(r1);
00197 if (r2 == t) {
00198 setProperty(t, key, nil);
00199 } else {
00200 setProperty(t, key, r2);
00201 }
00202 return r2;
00203 }
00204 }
00205
00206
00207
00208
00209
00215 static Tree sigMapRename (Tree key, Tree env, tfun f, Tree t)
00216 {
00217
00218 Tree p,id,body;
00219
00220 if (getProperty(t, key, p)) {
00221
00222 return (isNil(p)) ? t : p;
00223
00224 } else if (isRec(t, id, body)) {
00225
00226 assert(isRef(t,id));
00227
00228 Tree id2;
00229 if (searchEnv(id, id2, env)) {
00230
00231 return ref(id2);
00232 } else {
00233
00234 id2 = tree(Node(unique("renamed")));
00235 Tree body2 = sigMapRename(key, pushEnv(id, id2, env), f, body);
00236 return rec(id2,body2);
00237 }
00238
00239 } else {
00240
00241 Tree r1=nil;
00242 switch (t->arity()) {
00243
00244 case 0 :
00245 r1 = t;
00246 break;
00247 case 1 :
00248 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)));
00249 break;
00250 case 2 :
00251 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
00252 sigMapRename(key,env,f,t->branch(1)));
00253 break;
00254 case 3 :
00255 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
00256 sigMapRename(key,env,f,t->branch(1)),
00257 sigMapRename(key,env,f,t->branch(2)));
00258 break;
00259 case 4 :
00260 r1 = tree(t->node(), sigMapRename(key,env,f,t->branch(0)),
00261 sigMapRename(key,env,f,t->branch(1)),
00262 sigMapRename(key,env,f,t->branch(2)),
00263 sigMapRename(key,env,f,t->branch(3)));
00264 break;
00265 }
00266 Tree r2 = f(r1);
00267 if (r2 == t) {
00268 setProperty(t, key, nil);
00269 } else {
00270 setProperty(t, key, r2);
00271 }
00272 return r2;
00273 }
00274 }
00275
00276 #if 0
00277 static void eraseProperties (Tree key, Tree t)
00278 {
00279
00280 Tree p,id,body;
00281
00282 if (getProperty(t, key, p)) {
00283
00284
00285 } else if (isRec(t, id, body)) {
00286 t->clearProperties();
00287 Tree r=rec(id, body);
00288 assert(r==t);
00289 setProperty(t, key, nil);
00290 eraseProperties(key, body);
00291
00292 } else {
00293
00294 for (int i=0; i<t->arity(); i++) {
00295 eraseProperties(key,t->branch(i));
00296 }
00297 }
00298 }
00299
00300 void eraseAllProperties(Tree t)
00301 {
00302 cerr << "begin eraseAllProperties" << endl;
00303 eraseProperties(tree(Node(unique("erase_"))), t);
00304 cerr << "end eraseAllProperties" << endl;
00305 }
00306 #endif
00307
00313 Tree DOCTABLES = tree(symbol("DocTablesProp"));
00314
00315 static Tree docTableConverter (Tree sig);
00316
00317 Tree docTableConvertion (Tree sig)
00318 {
00319 Tree r = sigMapRename(DOCTABLES, NULLENV, docTableConverter, sig);
00320 return r;
00321 }
00322
00323
00324
00325
00326 static Tree docTableConverter (Tree sig)
00327 {
00328 Tree tbl, tbl2, id, id2, size, igen, isig, ridx, widx, wsig;
00329
00330 if (isSigRDTbl(sig, tbl, ridx)) {
00331
00332 if (isSigTable(tbl, id, size, igen)) {
00333
00334 assert(isSigGen(igen, isig));
00335 return sigDocAccessTbl(sigDocConstantTbl(size,isig),ridx);
00336 } else {
00337
00338 assert(isSigWRTbl(tbl,id,tbl2,widx,wsig));
00339 assert(isSigTable(tbl2, id2, size, igen));
00340 assert(isSigGen(igen, isig));
00341
00342 return sigDocAccessTbl(sigDocWriteTbl(size,isig,widx,wsig),ridx);
00343 }
00344
00345 } else {
00346
00347 return sig;
00348 }
00349 }