Lateq* DocCompiler::compileLateq (Tree L, Lateq* compiledEqn)
{
//cerr << "Documentator : compileLateq : L = "; printSignal(L, stdout, 0); cerr << endl;
fLateq = compiledEqn; ///< Dynamic field !
int priority = 0;
for (int i = 0; isList(L); L = tl(L), i++) {
Tree sig = hd(L);
Tree id;
if(getSigNickname(sig, id)) {
//cerr << "Documentator : compileLateq : NICKNAMEPROPERTY = " << tree2str(id) << endl;
fLateq->addOutputSigFormula(subst("$0(t) = $1", tree2str(id), CS(sig, priority), docT(i)));
} else {
//cerr << "Documentator : compileLateq : NO NICKNAMEPROPERTY" << endl;
if (fLateq->outputs() == 1) {
fLateq->addOutputSigFormula(subst("y(t) = $0", CS(sig, priority)));
gGlobal->gDocNoticeFlagMap["outputsig"] = true;
} else {
fLateq->addOutputSigFormula(subst("$0(t) = $1", getFreshID("y"), CS(sig, priority)));
gGlobal->gDocNoticeFlagMap["outputsigs"] = true;
}
}
}
return fLateq;
}
/**
* @brief Prepare "intervallic" user interface elements (sliders, nentry).
*
* - Format a LaTeX output string as a supertabular row with 3 columns :
* "\begin{supertabular}{lll}". @see Lateq::printHierarchy
* - The UI range is an bounded interval : [tmin, tmax].
* - The UI current value is tcur.
*
* @param[in] name The LaTeX name of the UI signal (eg. "{u_s}_{i}(t)").
* @param[in] path The path tree to parse.
* @param[in] tcur The current UI value tree to convert.
* @param[in] tmin The minimum UI value tree to convert.
* @param[in] tmax The maximum UI value tree to convert.
* @return <string> The LaTeX output string.
*/
string DocCompiler::prepareIntervallicUI(const string& name, Tree path, Tree tcur, Tree tmin, Tree tmax)
{
string label, unit, cur, min, max;
getUIDocInfos(path, label, unit);
cur = docT(tree2float(tcur));
min = docT(tree2float(tmin));
max = docT(tree2float(tmax));
string s = "";
label = (label.size() > 0) ? ("\\textsf{\"" + label + "\"} ") : "";
unit = (unit.size() > 0) ? ("\\ (" + unit + ")") : "";
s += label + unit;
s += " & $" + name + "$";
s += " $\\in$ $\\left[\\," + min + ", " + max + "\\,\\right]$";
s += " & $(\\mbox{" + gDocMathStringMap["defaultvalue"] + "} = " + cur + ")$\\\\";
return s;
}
/**
* Generate a "iota" time function, n-cyclical.
*/
string DocCompiler::generateIota (Tree sig, Tree n)
{
int size;
if (!isSigInt(n, &size)) {
throw faustexception("ERROR in generateIota\n");
}
//cout << "iota !" << endl;
return subst(" t \\bmod{$0} ", docT(size));
}
string DocCompiler::getFreshID(const string& prefix)
{
if (gGlobal->gIDCounters.find(prefix) == gGlobal->gIDCounters.end()) {
gGlobal->gIDCounters[prefix] = 1;
}
int n = gGlobal->gIDCounters[prefix];
gGlobal->gIDCounters[prefix] = n+1;
return subst("$0_{$1}", prefix, docT(n));
}
/**
* Generate a "iota" time function, n-cyclical.
*/
string DocCompiler::generateIota(Tree sig, Tree n)
{
int size;
if(!isSigInt(n, &size))
{
fprintf(stderr, "error in generateIota\n");
exit(1);
}
// cout << "iota !" << endl;
return subst(" t \\bmod{$0} ", docT(size));
}
/**
* @brief Main code generator dispatch.
*
* According to the type of the input signal, generateCode calls
* the appropriate generator with appropriate arguments.
*
* @param sig The signal expression to compile.
* @param priority The environment priority of the expression.
* @return <string> The LaTeX code translation of the signal.
*/
string DocCompiler::generateCode(Tree sig, int priority)
{
int i;
double r;
Tree c, sel, x, y, z, u, label, ff, largs, type, name, file;
if(getUserData(sig))
{
printGCCall(sig, "generateXtended");
return generateXtended(sig, priority);
}
else if(isSigInt(sig, &i))
{
printGCCall(sig, "generateNumber");
return generateNumber(sig, docT(i));
}
else if(isSigReal(sig, &r))
{
printGCCall(sig, "generateNumber");
return generateNumber(sig, docT(r));
}
else if(isSigInput(sig, &i))
{
printGCCall(sig, "generateInput");
return generateInput(sig, docT(i + 1));
}
else if(isSigOutput(sig, &i, x))
{
printGCCall(sig, "generateOutput");
return generateOutput(sig, docT(i + 1), CS(x, priority));
}
else if(isSigFixDelay(sig, x, y))
{
printGCCall(sig, "generateFixDelay");
return generateFixDelay(sig, x, y, priority);
}
else if(isSigPrefix(sig, x, y))
{
printGCCall(sig, "generatePrefix");
return generatePrefix(sig, x, y, priority);
}
else if(isSigIota(sig, x))
{
printGCCall(sig, "generateIota");
return generateIota(sig, x);
}
else if(isSigBinOp(sig, &i, x, y))
{
printGCCall(sig, "generateBinOp");
return generateBinOp(sig, i, x, y, priority);
}
else if(isSigFFun(sig, ff, largs))
{
printGCCall(sig, "generateFFun");
return generateFFun(sig, ff, largs, priority);
}
else if(isSigFConst(sig, type, name, file))
{
printGCCall(sig, "generateFConst");
return generateFConst(sig, tree2str(file), tree2str(name));
}
else if(isSigFVar(sig, type, name, file))
{
printGCCall(sig, "generateFVar");
return generateFVar(sig, tree2str(file), tree2str(name));
}
// new special tables for documentation purposes
else if(isSigDocConstantTbl(sig, x, y))
{
printGCCall(sig, "generateDocConstantTbl");
return generateDocConstantTbl(sig, x, y);
}
else if(isSigDocWriteTbl(sig, x, y, z, u))
{
printGCCall(sig, "generateDocWriteTbl");
return generateDocWriteTbl(sig, x, y, z, u);
}
else if(isSigDocAccessTbl(sig, x, y))
{
printGCCall(sig, "generateDocAccessTbl");
return generateDocAccessTbl(sig, x, y);
}
else if(isSigSelect2(sig, sel, x, y))
{
printGCCall(sig, "generateSelect2");
return generateSelect2(sig, sel, x, y, priority);
}
else if(isSigSelect3(sig, sel, x, y, z))
{
printGCCall(sig, "generateSelect3");
return generateSelect3(sig, sel, x, y, z, priority);
}
else if(isProj(sig, &i, x))
{
printGCCall(sig, "generateRecProj");
return generateRecProj(sig, x, i, priority);
}
else if(isSigIntCast(sig, x))
{
printGCCall(sig, "generateIntCast");
return generateIntCast(sig, x, priority);
}
else if(isSigFloatCast(sig, x))
{
printGCCall(sig, "generateFloatCast");
return generateFloatCast(sig, x, priority);
}
else if(isSigButton(sig, label))
{
printGCCall(sig, "generateButton");
return generateButton(sig, label);
}
else if(isSigCheckbox(sig, label))
{
printGCCall(sig, "generateCheckbox");
return generateCheckbox(sig, label);
}
else if(isSigVSlider(sig, label, c, x, y, z))
{
printGCCall(sig, "generateVSlider");
return generateVSlider(sig, label, c, x, y, z);
}
else if(isSigHSlider(sig, label, c, x, y, z))
{
printGCCall(sig, "generateHSlider");
return generateHSlider(sig, label, c, x, y, z);
}
else if(isSigNumEntry(sig, label, c, x, y, z))
{
printGCCall(sig, "generateNumEntry");
return generateNumEntry(sig, label, c, x, y, z);
}
else if(isSigVBargraph(sig, label, x, y, z))
{
printGCCall(sig, "generateVBargraph");
return CS(z, priority);
}// generateVBargraph (sig, label, x, y, CS(z, priority)); }
else if(isSigHBargraph(sig, label, x, y, z))
{
printGCCall(sig, "generateHBargraph");
return CS(z, priority);
}// generateHBargraph (sig, label, x, y, CS(z, priority)); }
else if(isSigAttach(sig, x, y))
{
printGCCall(sig, "generateAttach");
return generateAttach(sig, x, y, priority);
}
else
{
cerr << "Error in d signal, unrecognized signal : " << *sig << endl;
exit(1);
}
assert(0);
return "error in generate code";
}
