+++ /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.
- ************************************************************************
- ************************************************************************/
-
-/*****************************************************************************
- HISTORY
- 22/01/05 : corrected bug on bool signals cached in float variables
- 2009-08-16 : First "doc" version (kb)
- 2009-11-22 : Some clean up (kb)
-*****************************************************************************/
-
-
-
-
-#include <stdio.h>
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <math.h>
-
-#include "doc_compile.hh"
-#include "sigtype.hh"
-#include "floats.hh"
-#include "sigprint.hh"
-#include "sigtyperules.hh"
-#include "recursivness.hh"
-#include "simplify.hh"
-#include "privatise.hh"
-#include "prim2.hh"
-#include "xtended.hh"
-#include "compatibility.hh"
-#include "ppsig.hh"
-#include "names.hh"
-#include "doc.hh"
-#include "tlib.hh"
-#include "doc_notice.hh"
-
-
-extern bool gLessTempSwitch;
-extern int gMaxCopyDelay;
-extern map<string, string> gDocMathStringMap;
-
-extern bool getSigListNickName(Tree t, Tree& id);
-
-static const unsigned int MAX_RIGHT_MEMBER = 20;
-static const unsigned int MAX_SUB_EXPR = 10;
-
-
-/*****************************************************************************
- getFreshID
-*****************************************************************************/
-
-map<string, int> DocCompiler::fIDCounters;
-
-string DocCompiler::getFreshID(const string& prefix)
-{
- if (fIDCounters.find(prefix) == fIDCounters.end()) {
- fIDCounters[prefix] = 1;
- }
- int n = fIDCounters[prefix];
- fIDCounters[prefix] = n+1;
-
- return subst("$0_{$1}", prefix, docT(n));
-}
-
-
-/*****************************************************************************
- prepare
-*****************************************************************************/
-
-Tree DocCompiler::annotate(Tree LS)
-{
- recursivnessAnnotation(LS); // Annotate LS with recursivness information
- typeAnnotation(LS); // Annotate LS with type information
- sharingAnalysis(LS); // annotate LS with sharing count
- fOccMarkup.mark(LS); // annotate LS with occurences analysis
-
- return LS;
-}
-
-/*****************************************************************************
- compileLateq
-*****************************************************************************/
-
-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)));
- gDocNoticeFlagMap["outputsig"] = true;
- } else {
- fLateq->addOutputSigFormula(subst("$0(t) = $1", getFreshID("y"), CS(sig, priority)));
- gDocNoticeFlagMap["outputsigs"] = true;
- }
- }
- }
- return fLateq;
-}
-
-
-
-/*****************************************************************************
- CS : compile a signal
-*****************************************************************************/
-
-/**
- * Test if a signal is already compiled
- * @param sig the signal expression to compile.
- * @param name the string representing the compiled expression.
- * @return true is already compiled
- */
-bool DocCompiler::getCompiledExpression(Tree sig, string& cexp)
-{
- return fCompileProperty.get(sig, cexp);
-}
-
-
-/**
- * Set the string of a compiled expression is already compiled
- * @param sig the signal expression to compile.
- * @param cexp the string representing the compiled expression.
- * @return the cexp (for commodity)
- */
-string DocCompiler::setCompiledExpression(Tree sig, const string& cexp)
-{
- fCompileProperty.set(sig, cexp);
- return cexp;
-}
-
-
-/**
- * Compile a signal
- * @param sig the signal expression to compile.
- * @return the C code translation of sig as a string
- */
-string DocCompiler::CS (Tree sig, int priority)
-{
- string code;
-
- if (!getCompiledExpression(sig, code)) { // not compiled yet.
- code = generateCode(sig, priority);
- setCompiledExpression(sig, code);
- }
- return code;
-}
-
-
-
-/*****************************************************************************
- generateCode : dispatch according to signal
-*****************************************************************************/
-
-
-/**
- * @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";
-}
-
-
-/**
- * Print calling information of generateCode, for debug purposes.
- *
- * @remark
- * To turn printing on, turn the 'printCalls' boolean to true.
- */
-void DocCompiler::printGCCall(Tree sig, const string& calledFunction)
-{
- bool printCalls = false;
- bool maskSigs = false;
-
- if(printCalls) {
- cerr << " -> generateCode calls " << calledFunction;
- if(maskSigs) {
- cerr << endl;
- } else {
- cerr << " on " << ppsig(sig) << endl;
- }
- }
-}
-
-
-/*****************************************************************************
- NUMBERS
-*****************************************************************************/
-
-
-string DocCompiler::generateNumber (Tree sig, const string& exp)
-{
- string ctype, vname;
- Occurences* o = fOccMarkup.retrieve(sig);
-
- // check for number occuring in delays
- if (o->getMaxDelay()>0) {
- getTypedNames(getCertifiedSigType(sig), "r", ctype, vname);
- gDocNoticeFlagMap["recursigs"] = true;
- //cerr << "- r : generateNumber : \"" << vname << "\"" << endl;
- generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
- return exp;
-}
-
-/*****************************************************************************
- FOREIGN CONSTANTS
-*****************************************************************************/
-
-
-string DocCompiler::generateFConst (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);
- gDocNoticeFlagMap["recursigs"] = true;
- //cerr << "- r : generateFConst : \"" << vname << "\"" << endl;
- generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
-
- if (exp == "fSamplingFreq") {
- //gDocNoticeFlagMap["fsamp"] = true;
- return "f_S";
- }
-
- return "\\mathrm{"+exp+"}";
-}
-
-/*****************************************************************************
- FOREIGN VARIABLES
-*****************************************************************************/
-
-
-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);
- gDocNoticeFlagMap["recursigs"] = true;
- //cerr << "- r : generateFVar : \"" << vname << "\"" << endl;
- setVectorNameProperty(sig, vname);
- generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
- return generateCacheCode(sig, exp);
-}
-
-
-/*****************************************************************************
- INPUTS - OUTPUTS
-*****************************************************************************/
-
-
-string DocCompiler::generateInput (Tree sig, const string& idx)
-{
- if (fLateq->inputs() == 1) {
- setVectorNameProperty(sig, "x");
- fLateq->addInputSigFormula("x(t)");
- gDocNoticeFlagMap["inputsig"] = true;
- return generateCacheCode(sig, "x(t)");
- } else {
- setVectorNameProperty(sig, subst("x_{$0}", idx));
- fLateq->addInputSigFormula(subst("x_{$0}(t)", idx));
- gDocNoticeFlagMap["inputsigs"] = true;
- return generateCacheCode(sig, subst("x_{$0}(t)", idx));
- }
-}
-
-
-/** Unused for the moment ! */
-string DocCompiler::generateOutput (Tree sig, const string& idx, const string& arg)
-{
- string dst;
-
- if (fLateq->outputs() == 1) {
- dst = subst("y(t)", idx);
- gDocNoticeFlagMap["outputsig"] = true;
- } else {
- dst = subst("y_{$0}(t)", idx);
- gDocNoticeFlagMap["outputsigs"] = true;
- }
-
- fLateq->addOutputSigFormula(subst("$0 = $1", dst, arg));
- return dst;
-}
-
-
-/*****************************************************************************
- BINARY OPERATION
-*****************************************************************************/
-
-/**
- * Generate binary operations, managing priority parenthesis.
- * ((a*b)+c) can be written (a*b+c) if priority(*) > priority(+)
- * ((a*b)*c) can be writteb (a*b*c) if * is associative
- * Associative operation should have a distinc priority from other operations.
- * Non associative operations can share the same priority.
- *
- * @param sig The signal expression to treat.
- * @param opcode The operation code, as described in gBinOpLateqTable.
- * @param arg1 The first operand.
- * @param arg2 The second operand.
- * @param priority The priority of the environment of the expression.
- *
- * @return <string> The LaTeX code translation of the signal, cached.
- *
- * @remark The case of LaTeX frac{}{} is special.
- *
- * @todo Handle integer arithmetics, by testing arguments type,
- * and printing dedicated operators (\oplus, \odot, \ominus, \oslash).
- */
-
-/// associative operations are + * | & xor
-static bool associative (int opcode) {
- return (opcode == kAdd) || (opcode == kMul) || (opcode == kAND) || (opcode == kOR) || (opcode == kXOR);
-}
-
-string DocCompiler::generateBinOp(Tree sig, int opcode, Tree arg1, Tree arg2, int priority)
-{
- string s;
- int thisPriority = gBinOpLateqTable[opcode]->fPriority;
-
- /* Priority parenthesis handling. */
- string lpar = "";
- string rpar = "";
- if ( (thisPriority < priority) || ((thisPriority == priority) && !associative(opcode)) ) {
- // (a+b)*c or (a/b)/c need parenthesis
- lpar = " \\left(";
- rpar = "\\right) ";
- }
-
- Type t1 = getCertifiedSigType(arg1);
- Type t2 = getCertifiedSigType(arg2);
- bool intOpDetected = false;
- if ( (t1->nature() == kInt) && (t2->nature() == kInt) ) {
- intOpDetected = true;
- }
-
- string op;
- if(!intOpDetected) {
- op = gBinOpLateqTable[opcode]->fName;
- } else {
- switch (opcode) {
- case kAdd:
- op = "\\oplus";
- gDocNoticeFlagMap["intplus"] = true;
- break;
- case kSub:
- op = "\\ominus";
- gDocNoticeFlagMap["intminus"] = true;
- break;
- case kMul:
- op = "\\odot";
- gDocNoticeFlagMap["intmult"] = true;
- break;
- case kDiv:
- op = "\\oslash";
- gDocNoticeFlagMap["intdiv"] = true;
- gDocNoticeFlagMap["intcast"] = true; // "$normalize(int(i/j))$" in the notice.
- break;
- default:
- op = gBinOpLateqTable[opcode]->fName;
- break;
- }
- }
-
- /* LaTeX frac{}{} handling VS general case. */
- if ( (opcode == kDiv) && (!intOpDetected) ) {
- s = subst("$0\\frac{$1}{$2}$3", lpar, CS(arg1, 0), CS(arg2, 0), rpar);
- } else {
- s = subst("$0$1 $2 $3$4", lpar, CS(arg1, thisPriority), op, CS(arg2, thisPriority), rpar);
- }
-
-// if (opcode == kMul) {
-// gDocNoticeFlagMap["cdot"] = true;
-// }
-
- return generateCacheCode(sig, s);
-}
-
-
-/*****************************************************************************
- Primitive Operations
-*****************************************************************************/
-
-string DocCompiler::generateFFun(Tree sig, Tree ff, Tree largs, int priority)
-{
- string code = ffname(ff);
- code += '(';
- string sep = "";
- for (int i = 0; i< ffarity(ff); i++) {
- code += sep;
- code += CS(nth(largs, i), priority);
- sep = ", ";
- }
- code += ')';
-
- gDocNoticeFlagMap["foreignfun"] = true;
-
- return "\\mathrm{ff"+code+"}";
-}
-
-
-/*****************************************************************************
- CACHE CODE
-*****************************************************************************/
-
-void DocCompiler::getTypedNames(Type t, const string& prefix, string& ctype, string& vname)
-{
- if (t->nature() == kInt) {
- ctype = "int"; vname = subst("$0", getFreshID(prefix));
- } else {
- ctype = ifloat(); vname = subst("$0", getFreshID(prefix));
- }
-}
-
-
-/**
- * Test if exp is very simple that is it
- * can't be considered a real component
- * @param exp the signal we want to test
- * @return true if it a very simple signal
- */
-static bool isVerySimpleFormula(Tree sig)
-{
- int i;
- double r;
- Tree type, name, file, label, c, x, y, z;
-
- return isSigInt(sig, &i)
- || isSigReal(sig, &r)
- || isSigInput(sig, &i)
- || isSigFConst(sig, type, name, file)
- || isSigButton(sig, label)
- || isSigCheckbox(sig, label)
- || isSigVSlider(sig, label,c,x,y,z)
- || isSigHSlider(sig, label,c,x,y,z)
- || isSigNumEntry(sig, label,c,x,y,z)
- ;
-}
-
-
-string DocCompiler::generateCacheCode(Tree sig, const string& exp)
-{
- //cerr << "!! entering generateCacheCode with sig=\"" << ppsig(sig) << "\"" << endl;
-
- string vname, ctype, code, vectorname;
-
- int sharing = getSharingCount(sig);
- Occurences* o = fOccMarkup.retrieve(sig);
-
- // check reentrance
- if (getCompiledExpression(sig, code)) {
- //cerr << "!! generateCacheCode called a true getCompiledExpression" << endl;
- return code;
- }
-
- // check for expression occuring in delays
- if (o->getMaxDelay()>0) {
- if (getVectorNameProperty(sig, vectorname)) {
- return exp;
- }
- getTypedNames(getCertifiedSigType(sig), "r", ctype, vname);
- gDocNoticeFlagMap["recursigs"] = true;
- //cerr << "- r : generateCacheCode : vame=\"" << vname << "\", for sig=\"" << ppsig(sig) << "\"" << endl;
- if (sharing>1) {
- //cerr << " generateCacheCode calls generateDelayVec(generateVariableStore) on vame=\"" << vname << "\"" << endl;
- return generateDelayVec(sig, generateVariableStore(sig,exp), ctype, vname, o->getMaxDelay());
- } else {
- //cerr << " generateCacheCode calls generateDelayVec(exp) on vame=\"" << vname << "\"" << endl;
- return generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
- }
- else if (sharing == 1 || getVectorNameProperty(sig, vectorname) || isVerySimpleFormula(sig)) {
- //cerr << "! generateCacheCode : sharing == 1 : return \"" << exp << "\"" << endl;
- return exp;
- }
- else if (sharing > 1) {
- //cerr << "! generateCacheCode : sharing > 1 : return \"" << exp << "\"" << endl;
- return generateVariableStore(sig, exp);
- }
- else {
- cerr << "Error in sharing count (" << sharing << ") for " << *sig << endl;
- exit(1);
- }
-
- return "Error in generateCacheCode";
-}
-
-
-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 "";
- }
-}
-
-
-/*****************************************************************************
- CASTING
-*****************************************************************************/
-
-
-string DocCompiler::generateIntCast(Tree sig, Tree x, int priority)
-{
- gDocNoticeFlagMap["intcast"] = true;
-
- return generateCacheCode(sig, subst("\\mathrm{int}\\left($0\\right)", CS(x, 0)));
-}
-
-
-/**
- * @brief Don't generate float cast !
- *
- * It is just a kind of redirection.
- * Calling generateCacheCode ensures to create a new
- * variable name if the input signal expression is shared.
- */
-string DocCompiler::generateFloatCast (Tree sig, Tree x, int priority)
-{
- return generateCacheCode(sig, subst("$0", CS(x, priority)));
-}
-
-
-/*****************************************************************************
- user interface elements
-*****************************************************************************/
-
-string DocCompiler::generateButton(Tree sig, Tree path)
-{
- string vname = getFreshID("{u_b}");
- string varname = vname + "(t)";
- fLateq->addUISigFormula(getUIDir(path), prepareBinaryUI(varname, path));
- gDocNoticeFlagMap["buttonsigs"] = true;
- return generateCacheCode(sig, varname);
-}
-
-string DocCompiler::generateCheckbox(Tree sig, Tree path)
-{
- string vname = getFreshID("{u_c}");
- string varname = vname + "(t)";
- fLateq->addUISigFormula(getUIDir(path), prepareBinaryUI(varname, path));
- gDocNoticeFlagMap["checkboxsigs"] = true;
- return generateCacheCode(sig, varname);
-}
-
-string DocCompiler::generateVSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("{u_s}") + "(t)";
- fLateq->addUISigFormula(getUIDir(path), prepareIntervallicUI(varname, path, cur, min, max));
- gDocNoticeFlagMap["slidersigs"] = true;
- return generateCacheCode(sig, varname);
-}
-
-string DocCompiler::generateHSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("{u_s}") + "(t)";
- fLateq->addUISigFormula(getUIDir(path), prepareIntervallicUI(varname, path, cur, min, max));
- gDocNoticeFlagMap["slidersigs"] = true;
- return generateCacheCode(sig, varname);
-}
-
-string DocCompiler::generateNumEntry(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("{u_n}") + "(t)";
- fLateq->addUISigFormula(getUIDir(path), prepareIntervallicUI(varname, path, cur, min, max));
- gDocNoticeFlagMap["nentrysigs"] = true;
- return generateCacheCode(sig, varname);
-}
-
-
-string DocCompiler::generateVBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
-{
- string varname = getFreshID("{u_g}");
-
- Type t = getCertifiedSigType(sig);
- switch (t->variability()) {
-
- case kKonst :
- break;
-
- case kBlock :
- break;
-
- case kSamp :
- break;
- }
- return generateCacheCode(sig, varname);
-}
-
-
-string DocCompiler::generateHBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
-{
- string varname = getFreshID("{u_g}");
-
- Type t = getCertifiedSigType(sig);
- switch (t->variability()) {
-
- case kKonst :
- break;
-
- case kBlock :
- break;
-
- case kSamp :
- break;
- }
- return generateCacheCode(sig, varname);
-}
-
-
-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);
-}
-
-
-
-
-/*****************************************************************************
- TABLES
- (note : tables here are siplified versions different from the ones used to
- generate c++ code)
-*****************************************************************************/
-
-/**
- * Generate the equation of a constant table (its content is time constant).
- * Returns the name of the table
- */
-string DocCompiler::generateDocConstantTbl (Tree /*tbl*/, Tree size, Tree isig)
-{
- string vname, ctype;
- string init = CS(isig,0);
-
- int n;
- if (!isSigInt(size, &n)) {
- cerr << "error in DocCompiler::generateDocConstantTbl() : "
- << *size
- << " is not an integer expression and can't be used as a table size' "
- << endl;
- }
-
- // allocate a name v_i for the table
- getTypedNames(getCertifiedSigType(isig), "v", ctype, vname);
-
- // add a comment on tables in the notice
- gDocNoticeFlagMap["tablesigs"] = true;
-
- // add equation v[t] = isig(t)
- fLateq->addRDTblSigFormula(subst("$0[t] = $1 \\condition{when $$t \\in [0,$2]$$} ", vname, init, T(n-1)));
-
- // note that the name of the table can never be used outside an sigDocTableAccess
- return vname;
-}
-
-
-/**
- * tests if a charactere is a word separator
- */
-static bool isSeparator(char c)
-{
- bool w = ( ((c >= 'a') && (c <='z'))
- || ((c >= 'A') && (c <='Z'))
- || ((c >= '0') && (c <='9'))
- );
-
- return ! w;
-}
-
-
-/**
- * Replaces the occurences of 't' in a formula with another character
- */
-static string replaceTimeBy(const string& src, char r)
-{
- string dst;
- char pre = 0;
- for (size_t i=0; i < src.size(); i++)
- {
- char x = src[i];
- if ((x=='t') && isSeparator(pre) && ((i == src.size()-1) || isSeparator(src[i+1]))) {
- dst.push_back(r);
- } else {
- dst.push_back(x);
- }
- pre = x;
- }
- return dst;
-}
-
-/**
- * Generate the equation of a write table, which content is time dependent.
- * It is basically a signal of vectors.
- */
-string DocCompiler::generateDocWriteTbl (Tree /*tbl*/, Tree size, Tree isig, Tree widx, Tree wsig)
-{
- string vname, ctype;
- string init = CS(isig,0);
- int n;
- if (!isSigInt(size, &n)) {
- cerr << "error in DocCompiler::generateDocWriteTbl() : "
- << *size
- << " is not an integer expression and can't be used as a table size' "
- << endl;
- }
-
-
- // allocate a name w_i for the table
- getTypedNames(getCertifiedSigType(isig), "w", ctype, vname);
-
- // add a comment on tables in the notice
- gDocNoticeFlagMap["tablesigs"] = true;
-
- // describe the table equation
- string ltqRWTableDef;
- ltqRWTableDef += subst("$0(t)[i] = \n", vname);
- ltqRWTableDef += "\\left\\{\\begin{array}{ll}\n";
- ltqRWTableDef += subst("$0 & \\mbox{if \\,} t < 0 \\mbox{\\, and \\,} i \\in [0,$1] \\\\\n", replaceTimeBy(init,'i'), T(n-1));
- ltqRWTableDef += subst("$0 & \\mbox{if \\,} i = $1 \\\\\n", CS(wsig,0), CS(widx,0));
- ltqRWTableDef += subst("$0(t\\!-\\!1)[i] & \\mbox{otherwise} \\\\\n", vname);
- ltqRWTableDef += "\\end{array}\\right.";
-
- // add the table equation
- fLateq->addRWTblSigFormula(ltqRWTableDef); //w(t) = initsig(t)
-
- // note that the name of the table can never be used outside an sigDocTableAccess
- return vname;
-}
-
-
-/**
- * Generate the equation of a write table, which content is time dependent.
- * It is basically a signal of vectors.
- */
-string DocCompiler::generateDocAccessTbl (Tree sig, Tree tbl, Tree ridx)
-{
- // the compilation of a table always returns its name
- string vname = CS(tbl, 0);
- string result = subst("$0[$1]", vname, CS(ridx,0) );
-
- return generateCacheCode(sig, result);
-}
-
-bool DocCompiler::isShortEnough(string& s, unsigned int max)
-{
- return (s.length() <= max);
-}
-
-
-
-/*****************************************************************************
- RECURSIONS
-*****************************************************************************/
-
-
-/**
- * Generate code for a projection of a group of mutually recursive definitions
- */
-string DocCompiler::generateRecProj(Tree sig, Tree r, int i, int priority)
-{
- string vname;
- Tree var, le;
-
- //cerr << "*** generateRecProj sig : \"" << ppsig(sig) << "\"" << endl;
-
- if ( ! getVectorNameProperty(sig, vname)) {
- assert(isRec(r, var, le));
- //cerr << " generateRecProj has NOT YET a vname : " << endl;
- //cerr << "--> generateRecProj calls generateRec on \"" << ppsig(sig) << "\"" << endl;
- generateRec(r, var, le, priority);
- assert(getVectorNameProperty(sig, vname));
- //cerr << "<-- generateRecProj vname : \"" << subst("$0(t)", vname) << "\"" << endl;
- } else {
- //cerr << "(generateRecProj has already a vname : \"" << subst("$0(t)", vname) << "\")" << endl;
- }
- 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));
- }
- }
-}
-
-
-/*****************************************************************************
- PREFIX, DELAY A PREFIX VALUE
-*****************************************************************************/
-
-/**
- * Generate LaTeX code for "prefix", a 1sample-delay explicitely initialized.
- *
- * @param sig The signal expression to treat.
- * @param x The initial value for the delay line.
- * @param e The value for the delay line, after initialization.
- * @param priority The priority of the environment of the expression.
- *
- * @return <string> The LaTeX code translation of the signal, cached.
- */
-string DocCompiler::generatePrefix (Tree sig, Tree x, Tree e, int priority)
-{
- string var = getFreshID("m");
- string exp0 = CS(x, priority);
- string exp1 = CS(e, priority); // ensure exp1 is compiled to have a vector name
- string vecname;
-
- if (! getVectorNameProperty(e, vecname)) {
- cerr << "No vector name for : " << ppsig(e) << endl;
- assert(0);
- }
-
- string ltqPrefixDef;
- ltqPrefixDef += subst("$0(t) = \n", var);
- ltqPrefixDef += "\\left\\{\\begin{array}{ll}\n";
- ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t = 0\\\\\n", exp0);
- ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t > 0\n", subst("$0(t\\!-\\!1)", vecname));
- ltqPrefixDef += "\\end{array}\\right.";
-
- fLateq->addPrefixSigFormula(ltqPrefixDef);
- gDocNoticeFlagMap["prefixsigs"] = true;
-
- return generateCacheCode(sig, subst("$0(t)", var));
-}
-
-
-/*****************************************************************************
- IOTA(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));
-}
-
-
-
-// a revoir en utilisant la lecture de table et en partageant la construction de la paire de valeurs
-
-
-/**
- * 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 a select3 code
- */
-string DocCompiler::generateSelect3 (Tree sig, Tree sel, Tree s1, Tree s2, Tree s3, int priority)
-{
- string var = getFreshID("q");
- string expsel = CS(sel, 0);
- string exps1 = CS(s1, 0);
- string exps2 = CS(s2, 0);
- string exps3 = CS(s3, 0);
-
- string ltqSelDef;
- ltqSelDef += subst("$0(t) = \n", var);
- ltqSelDef += "\\left\\{\\begin{array}{ll}\n";
- ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 0\\\\\n", generateVariableStore(s1, exps1), expsel);
- ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 1\\\\\n", generateVariableStore(s2, exps2), expsel);
- ltqSelDef += subst("$0 & \\mbox{if \\,} $1 = 2\n", generateVariableStore(s3, exps3), 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);
-}
-
-
-/**
- * retrieve the type annotation of sig
- * @param sig the signal we want to know the type
- */
-string DocCompiler::generateXtended (Tree sig, int priority)
-{
- xtended* p = (xtended*) getUserData(sig);
- vector<string> args;
- vector<Type> types;
-
- for (int i=0; i<sig->arity(); i++) {
- args.push_back(CS(sig->branch(i), 0));
- types.push_back(getCertifiedSigType(sig->branch(i)));
- }
-
- if (p->needCache()) {
- //cerr << "!! generateXtended : <needCache> : calls generateCacheCode(sig, p->generateLateq(fLateq, args, types))" << endl;
- return generateCacheCode(sig, p->generateLateq(fLateq, args, types));
- } else {
- //cerr << "!! generateXtended : <do not needCache> : calls p->generateLateq(fLateq, args, types)" << endl;
- return p->generateLateq(fLateq, args, types);
- }
-}
-
-
-
-//------------------------------------------------------------------------------------------------
-
-
-/*****************************************************************************
- vector name property
-*****************************************************************************/
-
-/**
- * Set the vector name property of a signal, the name of the vector used to
- * store the previous values of the signal to implement a delay.
- * @param sig the signal expression.
- * @param vecname the string representing the vector name.
- * @return true is already compiled
- */
-void DocCompiler::setVectorNameProperty(Tree sig, const string& vecname)
-{
- fVectorProperty.set(sig, vecname);
-}
-
-
-/**
- * Get the vector name property of a signal, the name of the vector used to
- * store the previous values of the signal to implement a delay.
- * @param sig the signal expression.
- * @param vecname the string where to store the vector name.
- * @return true if the signal has this property, false otherwise
- */
-
-bool DocCompiler::getVectorNameProperty(Tree sig, string& vecname)
-{
- return fVectorProperty.get(sig, vecname);
-}
-
-
-
-/*****************************************************************************
- N-SAMPLE FIXED DELAY : sig = exp@delay
-
- case 1-sample max delay :
- Y(t-0) Y(t-1)
- Temp Var gLessTempSwitch = false
- V[0] V[1] gLessTempSwitch = true
-
- case max delay < gMaxCopyDelay :
- Y(t-0) Y(t-1) Y(t-2) ...
- Temp V[0] V[1] ... gLessTempSwitch = false
- V[0] V[1] V[2] ... gLessTempSwitch = true
-
- case max delay >= gMaxCopyDelay :
- Y(t-0) Y(t-1) Y(t-2) ...
- Temp V[0] V[1] ...
- V[0] V[1] V[2] ...
-
-
-*****************************************************************************/
-
-/**
- * Generate code for accessing a delayed signal. The generated code depend of
- * the maximum delay attached to exp and the gLessTempSwitch.
- *
- * @todo Priorités à revoir pour le parenthésage (associativité de - et /),
- * avec gBinOpLateqTable dans binop.cpp.
- */
-string DocCompiler::generateFixDelay (Tree sig, Tree exp, Tree delay, int priority)
-{
- int d;
- string vecname;
-
- CS(exp, 0); // ensure exp is compiled to have a vector name
-
- if (! getVectorNameProperty(exp, vecname)) {
- cerr << "No vector name for : " << ppsig(exp) << endl;
- assert(0);
- }
-
- if (isSigInt(delay, &d) && (d == 0)) {
- //cerr << "@ generateFixDelay : d = " << d << endl;
- return subst("$0(t)", vecname);
- } else {
- //cerr << "@ generateFixDelay : d = " << d << endl;
- return subst("$0(t\\!-\\!$1)", vecname, CS(delay, 7));
- }
-}
-
-
-/**
- * Generate code for the delay mecchanism. The generated code depend of the
- * maximum delay attached to exp and the "less temporaries" switch
- */
-string DocCompiler::generateDelayVec(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
-{
- string s = generateDelayVecNoTemp(sig, exp, ctype, vname, mxd);
- if (getCertifiedSigType(sig)->variability() < kSamp) {
- return exp;
- } else {
- return s;
- }
-}
-
-
-/**
- * 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)
-{
- assert(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 the delay mecchanism without using temporary variables
- */
-void DocCompiler::generateDelayLine(const string& ctype, const string& vname, int mxd, const string& exp)
-{
- //assert(mxd > 0);
- if (mxd == 0) {
- fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
- } else {
- fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
- }
-}
-
-
-
-
-/****************************************************************
- User interface element utilities.
- *****************************************************************/
-
-
-/**
- * @brief Get the directory of a user interface element.
- *
- * Convert the input reversed path tree into a string.
- * The name of the UI is stripped (the head of the path tree),
- * the rest of the tree is a list of pointed pairs, where the names
- * are contained by the tail of these pointed pairs.
- * Metadatas (begining by '[') are stripped.
- *
- * @param[in] pathname The path tree to convert.
- * @return <string> A directory-like string.
- */
-string DocCompiler::getUIDir(Tree pathname)
-{
- //cerr << "Documentator : getUIDir : print(pathname, stdout) = "; print(pathname, stdout); cerr << endl;
- string s;
- Tree dir = reverse(tl(pathname));
- while (!isNil(dir)) {
- string tmp = tree2str(tl(hd(dir)));
- if ( (tmp[0] != '[') && (!tmp.empty()) ) {
- s += tmp + '/';
- }
- dir = tl(dir);
- }
- return s;
-}
-
-
-/**
- * @brief Prepare binary user interface elements (button, checkbox).
- *
- * - Format a LaTeX output string as a supertabular row with 3 columns :
- * "\begin{supertabular}{lll}". @see Lateq::printHierarchy
- * - The UI range is only a set of two values : {0, 1}.
- * - The UI current value is automatically 0.
- *
- * @param[in] name The LaTeX name of the UI signal (eg. "{u_b}_{i}(t)").
- * @param[in] path The path tree to parse.
- * @return <string> The LaTeX output string.
- */
-string DocCompiler::prepareBinaryUI(const string& name, Tree path)
-{
- string label, unit;
- getUIDocInfos(path, label, unit);
- string s = "";
- label = (label.size()>0) ? ("\\textsf{\""+label+"\"} ") : "";
- unit = (unit.size()>0) ? ("\\ ("+unit+")") : "";
- s += label + unit;
- s += " & $" + name + "$";
- s += " $\\in$ $\\left\\{\\,0, 1\\,\\right\\}$";
- s += " & $(\\mbox{" + gDocMathStringMap["defaultvalue"] + "} = 0)$\\\\";
- return s;
-}
-
-
-/**
- * @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;
-}
-
-
-/**
- * Get information on a user interface element for documentation.
- *
- * @param[in] path The UI full pathname to parse.
- * @param[out] label The place to store the UI name.
- * @param[out] unit The place to store the UI unit.
- */
-void DocCompiler::getUIDocInfos(Tree path, string& label, string& unit)
-{
- label = "";
- unit = "";
-
- map<string, set<string> > metadata;
- extractMetadata(tree2str(hd(path)), label, metadata);
-
- set<string> myunits = metadata["unit"];
-// for (set<string>::iterator i = myunits.begin(); i != myunits.end(); i++) {
-// cerr << "Documentator : getUIDocInfos : metadata[\"unit\"] = " << *i << endl;
-// }
- for (map<string, set<string> >::iterator i = metadata.begin(); i != metadata.end(); i++) {
- const string& key = i->first;
- const set<string>& values = i->second;
- for (set<string>::const_iterator j = values.begin(); j != values.end(); j++) {
- if(key == "unit") unit += *j;
- }
- }
-}
-
-
projects / Faustine.git / blobdiff