+++ /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
-*****************************************************************************/
-
-
-#include "compile_scal.hh"
-#include "timing.hh"
-
-#include "compile.hh"
-#include "sigtype.hh"
-
-#include <stdio.h>
-#include <iostream>
-#include <fstream>
-#include <sstream>
-#include <vector>
-#include <math.h>
-
-#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 "sigToGraph.hh"
-
-using namespace std;
-
-extern bool gDrawSignals;
-extern bool gLessTempSwitch;
-extern int gMaxCopyDelay;
-extern string gClassName;
-extern string gMasterDocument;
-
-static Klass* signal2klass (const string& name, Tree sig)
-{
- Type t = getCertifiedSigType(sig); //, NULLENV);
- if (t->nature() == kInt) {
-
- ScalarCompiler C( new SigIntGenKlass(name) );
- C.compileSingleSignal(sig);
- return C.getClass();
-
- } else {
-
- ScalarCompiler C( new SigFloatGenKlass(name) );
- C.compileSingleSignal(sig);
- return C.getClass();
-
- }
-}
-
-
-/*****************************************************************************
- getFreshID
-*****************************************************************************/
-
-map<string, int> ScalarCompiler::fIDCounters;
-
-string ScalarCompiler::getFreshID(const string& prefix)
-{
- if (fIDCounters.find(prefix) == fIDCounters.end()) {
- fIDCounters[prefix]=0;
- }
- int n = fIDCounters[prefix];
- fIDCounters[prefix] = n+1;
- return subst("$0$1", prefix, T(n));
-}
-
-
-/*****************************************************************************
- prepare
-*****************************************************************************/
-
-extern bool gDumpNorm;
-
-Tree ScalarCompiler::prepare(Tree LS)
-{
-startTiming("ScalarCompiler::prepare");
- startTiming("deBruijn2Sym");
- Tree L1 = deBruijn2Sym(LS); // convert debruijn recursion into symbolic recursion
- endTiming("deBruijn2Sym");
- Tree L2 = simplify(L1); // simplify by executing every computable operation
- Tree L3 = privatise(L2); // Un-share tables with multiple writers
-
- // dump normal form
- if (gDumpNorm) {
- cout << ppsig(L3) << endl;
- exit(0);
- }
-
- recursivnessAnnotation(L3); // Annotate L3 with recursivness information
-
- startTiming("typeAnnotation");
- typeAnnotation(L3); // Annotate L3 with type information
- endTiming("typeAnnotation");
-
- sharingAnalysis(L3); // annotate L3 with sharing count
- fOccMarkup.mark(L3); // annotate L3 with occurences analysis
- //annotationStatistics();
-endTiming("ScalarCompiler::prepare");
-
- fRates = new RateInferrer(L3);
- if (gDrawSignals) {
- ofstream dotfile(subst("$0-sig.dot", gMasterDocument).c_str());
- sigToGraph(L3, dotfile, fRates);
- }
- return L3;
-}
-
-Tree ScalarCompiler::prepare2(Tree L0)
-{
-startTiming("ScalarCompiler::prepare2");
- recursivnessAnnotation(L0); // Annotate L0 with recursivness information
- typeAnnotation(L0); // Annotate L0 with type information
- sharingAnalysis(L0); // annotate L0 with sharing count
- fOccMarkup.mark(L0); // annotate L0 with occurences analysis
-endTiming("ScalarCompiler::prepare2");
-
- return L0;
-}
-
-/*****************************************************************************
- compileMultiSignal
-*****************************************************************************/
-
-void ScalarCompiler::compileMultiSignal (Tree L)
-{
- //contextor recursivness(0);
- L = prepare(L); // optimize, share and annotate expression
-
- for (int i = 0; i < fClass->inputs(); i++) {
- fClass->addZone3(subst("$1* input$0 = input[$0];", T(i), xfloat()));
- }
- for (int i = 0; i < fClass->outputs(); i++) {
- fClass->addZone3(subst("$1* output$0 = output[$0];", T(i), xfloat()));
- }
-
- for (int i = 0; isList(L); L = tl(L), i++) {
- Tree sig = hd(L);
- fClass->addExecCode(subst("output$0[i] = $2$1;", T(i), CS(sig), xcast()));
- }
- generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
- generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
- if (fDescription) {
- fDescription->ui(prepareUserInterfaceTree(fUIRoot));
- }
-}
-
-
-/*****************************************************************************
- compileSingleSignal
-*****************************************************************************/
-
-void ScalarCompiler::compileSingleSignal (Tree sig)
-{
- //contextor recursivness(0);
- sig = prepare2(sig); // optimize and annotate expression
- fClass->addExecCode(subst("output[i] = $0;", CS(sig)));
- generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
- generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
- if (fDescription) {
- fDescription->ui(prepareUserInterfaceTree(fUIRoot));
- }
-}
-
-
-/*****************************************************************************
- 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 ScalarCompiler::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 ScalarCompiler::setCompiledExpression(Tree sig, const string& cexp)
-{
- //cerr << "ScalarCompiler::setCompiledExpression : " << cexp << " ==> " << ppsig(sig) << endl;
- string old; if (fCompileProperty.get(sig, old) && (old != cexp)) {
- cerr << "ERROR already a compiled expression attached : " << old << " replaced by " << cexp << endl;
- exit(1);
- }
- 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 ScalarCompiler::CS (Tree sig)
-{
- //contextor contextRecursivness;
- string code;
-
- if (!getCompiledExpression(sig, code)) {
- // not compiled yet
-/* if (getRecursivness(sig) != contextRecursivness.get()) {
- contextRecursivness.set(getRecursivness(sig));
- }*/
- code = generateCode(sig);
- setCompiledExpression(sig, code);
- }
- return code;
-}
-
-/*****************************************************************************
- generateCode : dispatch according to signal
-*****************************************************************************/
-/**
- * Main code generator dispatch.
- * @param sig the signal expression to compile.
- * @return the C code translation of sig
- */
-
-string ScalarCompiler::generateCode (Tree sig)
-{
-#if 0
- fprintf(stderr, "CALL generateCode(");
- printSignal(sig, stderr);
- fprintf(stderr, ")\n");
-#endif
-
- int i;
- double r;
- Tree c, sel, x, y, z, label, id, ff, largs, type, name, file;
-
- //printf("compilation of %p : ", sig); print(sig); printf("\n");
-
- if ( getUserData(sig) ) { return generateXtended(sig); }
- else if ( isSigInt(sig, &i) ) { return generateNumber(sig, T(i)); }
- else if ( isSigReal(sig, &r) ) { return generateNumber(sig, T(r)); }
- else if ( isSigInput(sig, &i) ) { return generateInput (sig, T(i)); }
- else if ( isSigOutput(sig, &i, x) ) { return generateOutput (sig, T(i), CS(x));}
-
- else if ( isSigFixDelay(sig, x, y) ) { return generateFixDelay (sig, x, y); }
- else if ( isSigPrefix(sig, x, y) ) { return generatePrefix (sig, x, y); }
- else if ( isSigIota(sig, x) ) { return generateIota (sig, x); }
-
- else if ( isSigBinOp(sig, &i, x, y) ) { return generateBinOp (sig, i, x, y); }
- else if ( isSigFFun(sig, ff, largs) ) { return generateFFun (sig, ff, largs); }
- else if ( isSigFConst(sig, type, name, file) ) { return generateFConst(sig, tree2str(file), tree2str(name)); }
- else if ( isSigFVar(sig, type, name, file) ) { return generateFVar(sig, tree2str(file), tree2str(name)); }
-
- else if ( isSigTable(sig, id, x, y) ) { return generateTable (sig, x, y); }
- else if ( isSigWRTbl(sig, id, x, y, z) ) { return generateWRTbl (sig, x, y, z); }
- else if ( isSigRDTbl(sig, x, y) ) { return generateRDTbl (sig, x, y); }
-
- else if ( isSigSelect2(sig, sel, x, y) ) { return generateSelect2 (sig, sel, x, y); }
- else if ( isSigSelect3(sig, sel, x, y, z) ) { return generateSelect3 (sig, sel, x, y, z); }
-
- else if ( isSigGen(sig, x) ) { return generateSigGen (sig, x); }
-
- else if ( isProj(sig, &i, x) ) { return generateRecProj (sig, x, i); }
-
- else if ( isSigIntCast(sig, x) ) { return generateIntCast (sig, x); }
- else if ( isSigFloatCast(sig, x) ) { return generateFloatCast (sig, x); }
-
- else if ( isSigButton(sig, label) ) { return generateButton (sig, label); }
- else if ( isSigCheckbox(sig, label) ) { return generateCheckbox (sig, label); }
- else if ( isSigVSlider(sig, label,c,x,y,z) ) { return generateVSlider (sig, label, c,x,y,z); }
- else if ( isSigHSlider(sig, label,c,x,y,z) ) { return generateHSlider (sig, label, c,x,y,z); }
- else if ( isSigNumEntry(sig, label,c,x,y,z) ) { return generateNumEntry (sig, label, c,x,y,z); }
-
- else if ( isSigVBargraph(sig, label,x,y,z) ) { return generateVBargraph (sig, label, x, y, CS(z)); }
- else if ( isSigHBargraph(sig, label,x,y,z) ) { return generateHBargraph (sig, label, x, y, CS(z)); }
- else if ( isSigAttach(sig, x, y) ) { CS(y); return generateCacheCode(sig, CS(x)); }
-
- else if ( isSigUpSample(sig, x, y) ) { return generateUpSample(sig, x, y); }
- else if ( isSigDownSample(sig, x, y) ) { return generateDownSample(sig, x, y); }
-
-
- else {
- printf("Error in compiling signal, unrecognized signal : ");
- print(sig);
- printf("\n");
- exit(1);
- }
- return "error in generate code";
-}
-
-
-/*****************************************************************************
- NUMBERS
-*****************************************************************************/
-
-
-string ScalarCompiler::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), "Vec", ctype, vname);
- generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
- return exp;
-}
-
-/*****************************************************************************
- FOREIGN CONSTANTS
-*****************************************************************************/
-
-
-string ScalarCompiler::generateFConst (Tree sig, const string& file, const string& exp)
-{
- string ctype, vname;
- Occurences* o = fOccMarkup.retrieve(sig);
-
- addIncludeFile(file);
-
- if (o->getMaxDelay()>0) {
- getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
- generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
- return exp;
-}
-
-/*****************************************************************************
- FOREIGN VARIABLES
-*****************************************************************************/
-
-
-string ScalarCompiler::generateFVar (Tree sig, const string& file, const string& exp)
-{
- string ctype, vname;
-
- addIncludeFile(file);
- return generateCacheCode(sig, exp);
-}
-
-/*****************************************************************************
- INPUTS - OUTPUTS
-*****************************************************************************/
-
-
-string ScalarCompiler::generateInput (Tree sig, const string& idx)
-{
- return generateCacheCode(sig, subst("$1input$0[i]", idx, icast()));
-}
-
-
-string ScalarCompiler::generateOutput (Tree sig, const string& idx, const string& arg)
-{
- string dst = subst("output$0[i]", idx);
- fClass->addExecCode(subst("$0 = $2$1;", dst, arg, xcast()));
- return dst;
-}
-
-
-/*****************************************************************************
- BINARY OPERATION
-*****************************************************************************/
-
-string ScalarCompiler::generateBinOp(Tree sig, int opcode, Tree arg1, Tree arg2)
-{
- return generateCacheCode(sig, subst("($0 $1 $2)", CS(arg1), gBinOpTable[opcode]->fName, CS(arg2)));
-}
-
-
-/*****************************************************************************
- Primitive Operations
-*****************************************************************************/
-
-string ScalarCompiler::generateFFun(Tree sig, Tree ff, Tree largs)
-{
- addIncludeFile(ffincfile(ff)); //printf("inc file %s\n", ffincfile(ff));
- addLibrary(fflibfile(ff)); //printf("lib file %s\n", fflibfile(ff));
-
- string code = ffname(ff);
- code += '(';
- string sep = "";
- for (int i = 0; i< ffarity(ff); i++) {
- code += sep;
- code += CS(nth(largs, i));
- sep = ", ";
- }
- code += ')';
- return generateCacheCode(sig, code);
-}
-
-
-/*****************************************************************************
- CACHE CODE
-*****************************************************************************/
-
-void ScalarCompiler::getTypedNames(Type t, const string& prefix, string& ctype, string& vname)
-{
- if (t->nature() == kInt) {
- ctype = "int"; vname = subst("i$0", getFreshID(prefix));
- } else {
- ctype = ifloat(); vname = subst("f$0", getFreshID(prefix));
- }
-}
-
-string ScalarCompiler::generateCacheCode(Tree sig, const string& exp)
-{
- string vname, ctype, code;
- int sharing = getSharingCount(sig);
- Occurences* o = fOccMarkup.retrieve(sig);
-
- // check reentrance
- if (getCompiledExpression(sig, code)) {
- return code;
- }
-
- // check for expression occuring in delays
- if (o->getMaxDelay()>0) {
-
- getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
- if (sharing>1) {
- return generateDelayVec(sig, generateVariableStore(sig,exp), ctype, vname, o->getMaxDelay());
- } else {
- return generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
- }
-
- } else if (sharing == 1) {
-
- return exp;
-
- } else if (sharing > 1) {
-
- return generateVariableStore(sig, exp);
-
- } else {
- cerr << "Error in sharing count (" << sharing << ") for " << *sig << endl;
- exit(1);
- }
-
- return "Error in generateCacheCode";
-}
-
-
-string ScalarCompiler::generateVariableStore(Tree sig, const string& exp)
-{
- string vname, ctype;
- Type t = getCertifiedSigType(sig);
-
- switch (t->variability()) {
-
- case kKonst :
-
- getTypedNames(t, "Const", ctype, vname);
- fClass->addDeclCode(subst("$0 \t$1;", ctype, vname));
- fClass->addInitCode(subst("$0 = $1;", vname, exp));
- break;
-
- case kBlock :
-
- getTypedNames(t, "Slow", ctype, vname);
- fClass->addFirstPrivateDecl(vname);
- fClass->addZone2(subst("$0 \t$1 = $2;", ctype, vname, exp));
- break;
-
- case kSamp :
-
- getTypedNames(t, "Temp", ctype, vname);
- fClass->addExecCode(subst("$0 $1 = $2;", ctype, vname, exp));
- break;
- }
- return vname;
-}
-
-
-/*****************************************************************************
- CASTING
-*****************************************************************************/
-
-
-string ScalarCompiler::generateIntCast(Tree sig, Tree x)
-{
- return generateCacheCode(sig, subst("int($0)", CS(x)));
-}
-
-string ScalarCompiler::generateFloatCast (Tree sig, Tree x)
-{
- return generateCacheCode(sig, subst("$1($0)", CS(x), ifloat()));
-}
-
-/*****************************************************************************
- user interface elements
-*****************************************************************************/
-
-string ScalarCompiler::generateButton(Tree sig, Tree path)
-{
- string varname = getFreshID("fbutton");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- fClass->addInitCode(subst("$0 = 0.0;", varname));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
- return generateCacheCode(sig, varname);
-}
-
-string ScalarCompiler::generateCheckbox(Tree sig, Tree path)
-{
- string varname = getFreshID("fcheckbox");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- fClass->addInitCode(subst("$0 = 0.0;", varname));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
- return generateCacheCode(sig, varname);
-}
-
-
-string ScalarCompiler::generateVSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("fslider");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
- return generateCacheCode(sig, varname);
-}
-
-string ScalarCompiler::generateHSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("fslider");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
- return generateCacheCode(sig, varname);
-}
-
-string ScalarCompiler::generateNumEntry(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
-{
- string varname = getFreshID("fentry");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
- return generateCacheCode(sig, varname);
-}
-
-
-string ScalarCompiler::generateVBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
-{
- string varname = getFreshID("fbargraph");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
-
- Type t = getCertifiedSigType(sig);
- switch (t->variability()) {
-
- case kKonst :
- fClass->addInitCode(subst("$0 = $1;", varname, exp));
- break;
-
- case kBlock :
- fClass->addZone2(subst("$0 = $1;", varname, exp));
- break;
-
- case kSamp :
- fClass->addExecCode(subst("$0 = $1;", varname, exp));
- break;
- }
-
- //return varname;
- return generateCacheCode(sig, varname);
-}
-
-
-string ScalarCompiler::generateHBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
-{
- string varname = getFreshID("fbargraph");
- fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
- addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
-
- Type t = getCertifiedSigType(sig);
- switch (t->variability()) {
-
- case kKonst :
- fClass->addInitCode(subst("$0 = $1;", varname, exp));
- break;
-
- case kBlock :
- fClass->addZone2(subst("$0 = $1;", varname, exp));
- break;
-
- case kSamp :
- fClass->addExecCode(subst("$0 = $1;", varname, exp));
- break;
- }
-
- //return varname;
- return generateCacheCode(sig, varname);
-}
-
-
-
-
-/*****************************************************************************
- TABLES
-*****************************************************************************/
-
-
-
-/*----------------------------------------------------------------------------
- sigGen : initial table content
-----------------------------------------------------------------------------*/
-
-string ScalarCompiler::generateSigGen(Tree sig, Tree content)
-{
- string klassname = getFreshID("SIG");
- string signame = getFreshID("sig");
-
- fClass->addSubKlass(signal2klass(klassname, content));
- fClass->addInitCode(subst("$0 $1;", klassname, signame));
- fInstanceInitProperty.set(content, pair<string,string>(klassname,signame));
-
- return signame;
-}
-
-string ScalarCompiler::generateStaticSigGen(Tree sig, Tree content)
-{
- string klassname = getFreshID("SIG");
- string signame = getFreshID("sig");
-
- fClass->addSubKlass(signal2klass(klassname, content));
- fClass->addStaticInitCode(subst("$0 $1;", klassname, signame));
- fStaticInitProperty.set(content, pair<string,string>(klassname,signame));
-
- return signame;
-}
-
-
-/*----------------------------------------------------------------------------
- sigTable : table declaration
-----------------------------------------------------------------------------*/
-
-string ScalarCompiler::generateTable(Tree sig, Tree tsize, Tree content)
-{
- string generator(CS(content));
- Tree g;
- string cexp;
- string ctype, vname;
- int size;
-
- // already compiled but check if we need to add declarations
-
- assert ( isSigGen(content, g) );
- pair<string,string> kvnames;
- if ( ! fInstanceInitProperty.get(g, kvnames)) {
- // not declared here, we add a declaration
- bool b = fStaticInitProperty.get(g, kvnames);
- assert(b);
- fClass->addInitCode(subst("$0 $1;", kvnames.first, kvnames.second));
- }
-
- if (!isSigInt(tsize, &size)) {
- //fprintf(stderr, "error in ScalarCompiler::generateTable()\n"); exit(1);
- cerr << "error in ScalarCompiler::generateTable() : "
- << *tsize
- << " is not a constant integer table size expression "
- << endl;
- exit(1);
- }
- // definition du nom et du type de la table
- // A REVOIR !!!!!!!!!
- Type t = getCertifiedSigType(content);//, tEnv);
- if (t->nature() == kInt) {
- vname = getFreshID("itbl");
- ctype = "int";
- } else {
- vname = getFreshID("ftbl");
- ctype = ifloat();
- }
-
- // declaration de la table
- fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(size)));
-
- // initialisation du generateur de contenu
- fClass->addInitCode(subst("$0.init(samplingFreq);", generator));
- // remplissage de la table
- fClass->addInitCode(subst("$0.fill($1,$2);", generator, T(size), vname));
-
- // on retourne le nom de la table
- return vname;
-}
-
-string ScalarCompiler::generateStaticTable(Tree sig, Tree tsize, Tree content)
-{
- //string generator(CS(content));
- Tree g;
- string cexp;
- string ctype, vname;
- int size;
-
- assert ( isSigGen(content, g) );
-
- if (!getCompiledExpression(content, cexp)) {
- cexp = setCompiledExpression(content, generateStaticSigGen(content, g));
- } else {
- // already compiled but check if we need to add declarations
- pair<string,string> kvnames;
- if ( ! fStaticInitProperty.get(g, kvnames)) {
- // not declared here, we add a declaration
- bool b = fInstanceInitProperty.get(g, kvnames);
- assert(b);
- fClass->addStaticInitCode(subst("$0 $1;", kvnames.first, kvnames.second));
- }
- }
-
- if (!isSigInt(tsize, &size)) {
- //fprintf(stderr, "error in ScalarCompiler::generateTable()\n"); exit(1);
- cerr << "error in ScalarCompiler::generateTable() : "
- << *tsize
- << " is not a constant integer table size expression "
- << endl;
- exit(1);
- }
- // definition du nom et du type de la table
- // A REVOIR !!!!!!!!!
- Type t = getCertifiedSigType(content);//, tEnv);
- if (t->nature() == kInt) {
- vname = getFreshID("itbl");
- ctype = "int";
- } else {
- vname = getFreshID("ftbl");
- ctype = ifloat();
- }
-
- // declaration de la table
- fClass->addDeclCode(subst("static $0 \t$1[$2];", ctype, vname, T(size)));
- fClass->addStaticFields(subst("$0 \t$1::$2[$3];", ctype, fClass->getClassName(), vname, T(size) ));
-
- // initialisation du generateur de contenu
- fClass->addStaticInitCode(subst("$0.init(samplingFreq);", cexp));
- // remplissage de la table
- fClass->addStaticInitCode(subst("$0.fill($1,$2);", cexp, T(size), vname));
-
- // on retourne le nom de la table
- return vname;
-}
-
-
-/*----------------------------------------------------------------------------
- sigWRTable : table assignement
-----------------------------------------------------------------------------*/
-
-string ScalarCompiler::generateWRTbl(Tree sig, Tree tbl, Tree idx, Tree data)
-{
- string tblName(CS(tbl));
- fClass->addExecCode(subst("$0[$1] = $2;", tblName, CS(idx), CS(data)));
- return tblName;
-}
-
-
-/*----------------------------------------------------------------------------
- sigRDTable : table access
-----------------------------------------------------------------------------*/
-
-string ScalarCompiler::generateRDTbl(Tree sig, Tree tbl, Tree idx)
-{
- // YO le 21/04/05 : La lecture des tables n'�ait pas mise dans le cache
- // et donc le code �ait dupliqu�(dans tester.dsp par exemple)
- //return subst("$0[$1]", CS(tEnv, tbl), CS(tEnv, idx));
-
- //cerr << "generateRDTable " << *sig << endl;
- // test the special case of a read only table that can be compiled
- // has a static member
- Tree id, size, content;
- if( isSigTable(tbl, id, size, content) ) {
- string tblname;
- if (!getCompiledExpression(tbl, tblname)) {
- tblname = setCompiledExpression(tbl, generateStaticTable(tbl, size, content));
- }
- return generateCacheCode(sig, subst("$0[$1]", tblname, CS(idx)));
- } else {
- return generateCacheCode(sig, subst("$0[$1]", CS(tbl), CS(idx)));
- }
-}
-
-
-
-/*****************************************************************************
- RECURSIONS
-*****************************************************************************/
-
-
-/**
- * Generate code for a projection of a group of mutually recursive definitions
- */
-string ScalarCompiler::generateRecProj(Tree sig, Tree r, int i)
-{
- string vname;
- Tree var, le;
-
- if ( ! getVectorNameProperty(sig, vname)) {
- assert(isRec(r, var, le));
- generateRec(r, var, le);
- assert(getVectorNameProperty(sig, vname));
- }
- return "[[UNUSED EXP]]"; // make sure the resulting expression is never used in the generated code
-}
-
-
-/**
- * Generate code for a group of mutually recursive definitions
- */
-void ScalarCompiler::generateRec(Tree sig, Tree var, Tree le)
-{
- 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;
- getTypedNames(getCertifiedSigType(e), "Rec", ctype[i], vname[i]);
- 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;
- }
- }
-
- // 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)));
- }
- }
-}
-
-
-/*****************************************************************************
- PREFIX, DELAY A PREFIX VALUE
-*****************************************************************************/
-
-string ScalarCompiler::generatePrefix (Tree sig, Tree x, Tree e)
-{
- Type te = getCertifiedSigType(sig);//, tEnv);
-
- string vperm = getFreshID("M");
- string vtemp = getFreshID("T");
-
- string type = cType(te);
-
- fClass->addDeclCode(subst("$0 \t$1;", type, vperm));
- fClass->addInitCode(subst("$0 = $1;", vperm, CS(x)));
-
- fClass->addExecCode(subst("$0 $1 = $2;", type, vtemp, vperm));
- fClass->addExecCode(subst("$0 = $1;", vperm, CS(e)));
- return vtemp;
-}
-
-
-/*****************************************************************************
- IOTA(n)
-*****************************************************************************/
-static bool isPowerOf2(int n)
-{
- return !(n & (n - 1));
-}
-
-string ScalarCompiler::generateIota (Tree sig, Tree n)
-{
- int size;
- if (!isSigInt(n, &size)) { fprintf(stderr, "error in generateIota\n"); exit(1); }
-
- string vperm = getFreshID("iota");
-
- fClass->addDeclCode(subst("int \t$0;", vperm));
- fClass->addInitCode(subst("$0 = 0;", vperm));
-
- if (isPowerOf2(size)) {
- fClass->addExecCode(subst("$0 = ($0+1)&$1;", vperm, T(size-1)));
- } else {
- fClass->addExecCode(subst("if (++$0 == $1) $0=0;", vperm, T(size)));
- }
- return vperm;
-}
-
-
-
-// a revoir en utilisant la lecture de table et en partageant la construction de la paire de valeurs
-
-
-/**
- * Generate a select2 code
- */
-
-string ScalarCompiler::generateSelect2 (Tree sig, Tree sel, Tree s1, Tree s2)
-{
- return generateCacheCode(sig, subst( "(($0)?$1:$2)", CS(sel), CS(s2), CS(s1) ) );
-}
-
-
-/**
- * Generate a select3 code (using if-then-else)
- * ((int n = sel==0)? s0 : ((sel==1)? s1 : s2))
- * int nn; ((nn=sel) ? ((nn==1)? s1 : s2) : s0);
- */
-string ScalarCompiler::generateSelect3 (Tree sig, Tree sel, Tree s1, Tree s2, Tree s3)
-{
- return generateCacheCode(sig, subst( "(($0==0)? $1 : (($0==1)?$2:$3) )", CS(sel), CS(s1), CS(s2), CS(s3) ) );
-}
-
-#if 0
-string ScalarCompiler::generateSelect3 (Tree sig, Tree sel, Tree s1, Tree s2, Tree s3)
-{
- Type t = getCertifiedSigType(sig);
- Type t1 = getCertifiedSigType(s1);
- Type t2 = getCertifiedSigType(s2);
- Type t3 = getCertifiedSigType(s3);
- Type w = min(t1,min(t2,t3));
-
- string type = cType(t);
- string var = getFreshID("S");
-
- switch (w->variability())
- {
- case kKonst :
- fClass->addDeclCode(subst("$0 \t$1[3];", type, var));
- break;
- case kBlock :
- //fClass->addLocalDecl(type, subst("$0[3]", var));
- //fClass->addLocalVecDecl(type, var, 3);
- fClass->addSharedDecl(var);
- fClass->addZone1(subst("$0 \t$1[3];", type, var));
- break;
- case kSamp :
- fClass->addExecCode(subst("$0 \t$1[3];", type, var));
- break;
- }
-
- switch (t1->variability())
- {
- case kKonst :
- fClass->addInitCode(subst("$0[0] = $1;", var, CS(s1)));
- break;
- case kBlock :
- fClass->addZone2b(subst("$0[0] = $1;", var, CS(s1)));
- break;
- case kSamp :
- fClass->addExecCode(subst("$0[0] = $1;", var, CS(s1)));
- break;
- }
-
- switch (t2->variability())
- {
- case kKonst :
- fClass->addInitCode(subst("$0[1] = $1;", var, CS(s2)));
- break;
- case kBlock :
- fClass->addZone2b(subst("$0[1] = $1;", var, CS(s2)));
- break;
- case kSamp :
- fClass->addExecCode(subst("$0[1] = $1;", var, CS(s2)));
- break;
- }
-
- switch (t3->variability())
- {
- case kKonst :
- fClass->addInitCode(subst("$0[2] = $1;", var, CS(s3)));
- break;
- case kBlock :
- fClass->addZone2b(subst("$0[2] = $1;", var, CS(s3)));
- break;
- case kSamp :
- fClass->addExecCode(subst("$0[2] = $1;", var, CS(s3)));
- break;
- }
-
- return generateCacheCode(sig, subst("$0[$1]", var, CS(sel)));
-}
-#endif
-
-/**
- * retrieve the type annotation of sig
- * @param sig the signal we want to know the type
- */
-string ScalarCompiler::generateXtended (Tree sig)
-{
- 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)));
- types.push_back(getCertifiedSigType(sig->branch(i)));
- }
-
- if (p->needCache()) {
- return generateCacheCode(sig, p->generateCode(fClass, args, types));
- } else {
- return p->generateCode(fClass, 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 ScalarCompiler::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 ScalarCompiler::getVectorNameProperty(Tree sig, string& vecname)
-{
- return fVectorProperty.get(sig, vecname);
-}
-
-
-/**
- * Compute the minimal power of 2 greater than x
- */
-
-int ScalarCompiler::pow2limit(int x)
-{
- int n = 2;
- while (n < x) { n = 2*n; }
- return n;
-}
-
-/*****************************************************************************
- 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.
- */
-
-string ScalarCompiler::generateFixDelay (Tree sig, Tree exp, Tree delay)
-{
- int mxd, d;
- string vecname;
-
- //cerr << "ScalarCompiler::generateFixDelay sig = " << *sig << endl;
- //cerr << "ScalarCompiler::generateFixDelay exp = " << *exp << endl;
- //cerr << "ScalarCompiler::generateFixDelay del = " << *delay << endl;
-
- CS(exp); // ensure exp is compiled to have a vector name
-
- mxd = fOccMarkup.retrieve(exp)->getMaxDelay();
-
- if (! getVectorNameProperty(exp, vecname)) {
- cerr << "No vector name for : " << ppsig(exp) << endl;
- assert(0);
- }
-
- if (mxd == 0) {
- // not a real vector name but a scalar name
- return vecname;
-
- } else if (mxd < gMaxCopyDelay) {
- if (isSigInt(delay, &d)) {
- return subst("$0[$1]", vecname, CS(delay));
- } else {
- return generateCacheCode(sig, subst("$0[$1]", vecname, CS(delay)));
- }
-
- } else {
-
- // long delay : we use a ring buffer of size 2^x
- int N = pow2limit( mxd+1 );
- return generateCacheCode(sig, subst("$0[(IOTA-$1)&$2]", vecname, CS(delay), T(N-1)));
- }
-}
-
-
-/**
- * Generate code for the delay mecchanism. The generated code depend of the
- * maximum delay attached to exp and the "less temporaries" switch
- */
-
-string ScalarCompiler::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 ScalarCompiler::generateDelayVecNoTemp(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
-{
- assert(mxd > 0);
-
- //bool odocc = fOccMarkup.retrieve(sig)->hasOutDelayOccurences();
-
- if (mxd < gMaxCopyDelay) {
-
- // short delay : we copy
- fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(mxd+1)));
- fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(mxd+1)));
- fClass->addExecCode(subst("$0[0] = $1;", vname, exp));
-
- // generate post processing copy code to update delay values
- if (mxd == 1) {
- fClass->addPostCode(subst("$0[1] = $0[0];", vname));
- } else if (mxd == 2) {
- //fClass->addPostCode(subst("$0[2] = $0[1];", vname));
- fClass->addPostCode(subst("$0[2] = $0[1]; $0[1] = $0[0];", vname));
- } else {
- fClass->addPostCode(subst("for (int i=$0; i>0; i--) $1[i] = $1[i-1];", T(mxd), vname));
- }
- setVectorNameProperty(sig, vname);
- return subst("$0[0]", vname);
-
- } else {
-
- // generate code for a long delay : we use a ring buffer of size N = 2**x > mxd
- int N = pow2limit(mxd+1);
-
- // we need a iota index
- ensureIotaCode();
-
- // declare and init
- fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(N)));
- fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(N)));
-
- // execute
- fClass->addExecCode(subst("$0[IOTA&$1] = $2;", vname, T(N-1), exp));
- setVectorNameProperty(sig, vname);
- return subst("$0[IOTA&$1]", vname, T(N-1));
- }
-}
-
-/**
- * Generate code for the delay mecchanism without using temporary variables
- */
-
-void ScalarCompiler::generateDelayLine(const string& ctype, const string& vname, int mxd, const string& exp)
-{
- //assert(mxd > 0);
- if (mxd == 0) {
- // cerr << "MXD==0 : " << vname << " := " << exp << endl;
- // no need for a real vector
- fClass->addExecCode(subst("$0 \t$1 = $2;", ctype, vname, exp));
-
-
- } else if (mxd < gMaxCopyDelay) {
- // cerr << "small delay : " << vname << "[" << mxd << "]" << endl;
-
- // short delay : we copy
- fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(mxd+1)));
- fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(mxd+1)));
- fClass->addExecCode(subst("$0[0] = $1;", vname, exp));
-
- // generate post processing copy code to update delay values
- if (mxd == 1) {
- fClass->addPostCode(subst("$0[1] = $0[0];", vname));
- } else if (mxd == 2) {
- fClass->addPostCode(subst("$0[2] = $0[1]; $0[1] = $0[0];", vname));
- } else {
- fClass->addPostCode(subst("for (int i=$0; i>0; i--) $1[i] = $1[i-1];", T(mxd), vname));
- }
-
- } else {
-
- // generate code for a long delay : we use a ring buffer of size N = 2**x > mxd
- int N = pow2limit(mxd+1);
-
- // we need a iota index
- ensureIotaCode();
-
- // declare and init
- fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(N)));
- fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(N)));
-
- // execute
- fClass->addExecCode(subst("$0[IOTA&$1] = $2;", vname, T(N-1), exp));
- }
-}
-
-/**
- * Generate up sampling code
- */
-
-string ScalarCompiler::generateUpSample(Tree sig, Tree w, Tree x)
-{
- return CS(x);
-}
-
-/**
- * Generate down sampling code
- */
-
-string ScalarCompiler::generateDownSample(Tree sig, Tree w, Tree x)
-{
- return CS(x);
-}
-
-
-/**
- * Generate code for a unique IOTA variable increased at each sample
- * and used to index ring buffers.
- */
-void ScalarCompiler::ensureIotaCode()
-{
- if (!fHasIota) {
- fHasIota = true;
- fClass->addDeclCode("int \tIOTA;");
- fClass->addInitCode("IOTA = 0;");
- fClass->addPostCode("IOTA = IOTA+1;");
- }
-}
projects / Faustine.git / blobdiff