string DocCompiler::generateInput (Tree sig, const string& idx)
{
if (fLateq->inputs() == 1) {
setVectorNameProperty(sig, "x");
fLateq->addInputSigFormula("x(t)");
gGlobal->gDocNoticeFlagMap["inputsig"] = true;
return generateCacheCode(sig, "x(t)");
} else {
setVectorNameProperty(sig, subst("x_{$0}", idx));
fLateq->addInputSigFormula(subst("x_{$0}(t)", idx));
gGlobal->gDocNoticeFlagMap["inputsigs"] = true;
return generateCacheCode(sig, subst("x_{$0}(t)", idx));
}
}
string VectorCompiler::generateDelayVec(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
{
// it is a non-sample but used delayed
// we need a delay line
generateDelayLine(ctype, vname, mxd, exp);
setVectorNameProperty(sig, vname);
if (verySimple(sig)) {
return exp;
} else {
return subst("$0[i]", vname);
}
}
string DocCompiler::generateVariableStore(Tree sig, const string& exp)
{
string vname, ctype;
Type t = getCertifiedSigType(sig);
switch(t->variability())
{
case kKonst:
getTypedNames(t, "k", ctype, vname); ///< "k" for constants.
fLateq->addConstSigFormula(subst("$0 = $1", vname, exp));
gDocNoticeFlagMap["constsigs"] = true;
return vname;
case kBlock:
getTypedNames(t, "p", ctype, vname); ///< "p" for "parameter".
fLateq->addParamSigFormula(subst("$0(t) = $1", vname, exp));
gDocNoticeFlagMap["paramsigs"] = true;
setVectorNameProperty(sig, vname);
return subst("$0(t)", vname);
case kSamp:
if(getVectorNameProperty(sig, vname))
{
return subst("$0(t)", vname);
}
else
{
getTypedNames(t, "s", ctype, vname);
// cerr << "- generateVariableStore : \"" << subst("$0(t) = $1", vname, exp) << "\"" << endl;
fLateq->addStoreSigFormula(subst("$0(t) = $1", vname, exp));
gDocNoticeFlagMap["storedsigs"] = true;
setVectorNameProperty(sig, vname);
return subst("$0(t)", vname);
}
default:
assert(0);
return "";
}
}
string DocCompiler::generateAttach (Tree sig, Tree x, Tree y, int priority)
{
string vname;
string exp;
CS(y, priority);
exp = CS(x, priority);
if(getVectorNameProperty(x, vname)) {
setVectorNameProperty(sig, vname);
}
return generateCacheCode(sig, exp);
}
string DocCompiler::generateFVar (Tree sig, const string& file, const string& exp)
{
string ctype, vname;
Occurences* o = fOccMarkup.retrieve(sig);
if (o->getMaxDelay()>0) {
getTypedNames(getCertifiedSigType(sig), "r", ctype, vname);
gGlobal->gDocNoticeFlagMap["recursigs"] = true;
//cerr << "- r : generateFVar : \"" << vname << "\"" << endl;
setVectorNameProperty(sig, vname);
generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
}
return generateCacheCode(sig, exp);
}
/**
* Generate code for the delay mecchanism without using temporary variables
*/
string DocCompiler::generateDelayVecNoTemp(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
{
faustassert(mxd > 0);
//cerr << " entering generateDelayVecNoTemp" << endl;
string vectorname;
// if generateVariableStore has already tagged sig, no definition is needed.
if(getVectorNameProperty(sig, vectorname)) {
return subst("$0(t)", vectorname);
} else {
fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
setVectorNameProperty(sig, vname);
return subst("$0(t)", vname);
}
}
/**
* Generate code for a group of mutually recursive definitions
*/
void DocCompiler::generateRec(Tree sig, Tree var, Tree le, int priority)
{
int N = len(le);
vector<bool> used(N);
vector<int> delay(N);
vector<string> vname(N);
vector<string> ctype(N);
// prepare each element of a recursive definition
for(int i = 0; i < N; i++)
{
Tree e = sigProj(i, sig); // recreate each recursive definition
if(fOccMarkup.retrieve(e))
{
// this projection is used
used[i] = true;
// cerr << "generateRec : used[" << i << "] = true" << endl;
getTypedNames(getCertifiedSigType(e), "r", ctype[i], vname[i]);
gDocNoticeFlagMap["recursigs"] = true;
// cerr << "- r : generateRec setVectorNameProperty : \"" << vname[i] << "\"" << endl;
setVectorNameProperty(e, vname[i]);
delay[i] = fOccMarkup.retrieve(e)->getMaxDelay();
}
else
{
// this projection is not used therefore
// we should not generate code for it
used[i] = false;
// cerr << "generateRec : used[" << i << "] = false" << endl;
}
}
// generate delayline for each element of a recursive definition
for(int i = 0; i < N; i++)
{
if(used[i])
{
generateDelayLine(ctype[i], vname[i], delay[i], CS(nth(le, i), priority));
}
}
}
/**
* Generate a select2 code
*/
string DocCompiler::generateSelect2(Tree sig, Tree sel, Tree s1, Tree s2, int priority)
{
string var = getFreshID("q");
string expsel = CS(sel, 0);
string exps1 = CS(s1, 0);
string exps2 = CS(s2, 0);
string ltqSelDef;
ltqSelDef += subst("$0(t) = \n", var);
ltqSelDef += "\\left\\{\\begin{array}{ll}\n";
ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 0\\\\\n", exps1, expsel);
ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 1\n", exps2, expsel);
ltqSelDef += "\\end{array}\\right.";
fLateq->addSelectSigFormula(ltqSelDef);
gDocNoticeFlagMap["selectionsigs"] = true;
// return generateCacheCode(sig, subst("$0(t)", var));
setVectorNameProperty(sig, var);
return subst("$0(t)", var);
}
/**
* Generate cache code for a signal if needed
* @param sig the signal expression.
* @param exp the corresponding C code.
* @return the cached C code
*/
string VectorCompiler::generateCacheCode(Tree sig, const string& exp)
{
string vname, ctype;
int sharing = getSharingCount(sig);
Type t = getCertifiedSigType(sig);
Occurences* o = fOccMarkup.retrieve(sig);
int d = o->getMaxDelay();
if (t->variability() < kSamp) {
if (d==0) {
// non-sample, not delayed : same as scalar cache
return ScalarCompiler::generateCacheCode(sig,exp);
} else {
// it is a non-sample expressions but used delayed
// we need a delay line
getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
if ((sharing > 1) && !verySimple(sig)) {
// first cache this expression because it
// it is shared and complex
string cachedexp = generateVariableStore(sig, exp);
generateDelayLine(ctype, vname, d, cachedexp);
setVectorNameProperty(sig, vname);
return cachedexp;
} else {
// no need to cache this expression because
// it is either not shared or very simple
generateDelayLine(ctype, vname, d, exp);
setVectorNameProperty(sig, vname);
return exp;
}
}
} else {
// sample-rate signal
if (d > 0) {
// used delayed : we need a delay line
getTypedNames(getCertifiedSigType(sig), "Yec", ctype, vname);
generateDelayLine(ctype, vname, d, exp);
setVectorNameProperty(sig, vname);
if (verySimple(sig)) {
return exp;
} else {
if (d < gMaxCopyDelay) {
return subst("$0[i]", vname);
} else {
// we use a ring buffer
string mask = T(pow2limit(d + gVecSize)-1);
return subst("$0[($0_idx+i) & $1]", vname, mask);
}
}
} else {
// not delayed
if ( sharing > 1 && ! verySimple(sig) ) {
// shared and not simple : we need a vector
// cerr << "ZEC : " << ppsig(sig) << endl;
getTypedNames(getCertifiedSigType(sig), "Zec", ctype, vname);
generateDelayLine(ctype, vname, d, exp);
setVectorNameProperty(sig, vname);
return subst("$0[i]", vname);
} else {
// not shared or simple : no cache needed
return exp;
}
}
}
}
