+++ /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.
- ************************************************************************
- ************************************************************************/
-
-
-
-#include "tree.hh"
-#include "sigtype.hh"
-#include "property.hh"
-
-int AudioType::gAllocationCount = 0;
-
-bool SimpleType::isMaximal() const ///< true when type is maximal (and therefore can't change depending of hypothesis)
-{
- return (fNature==kReal)
- && (fVariability==kSamp)
- && (fComputability==kExec);
-
-}
-
-
-//------------------------------------------------------------------------------------
-//
-// Surcharges de l'operateur d'impression <<
-//
-//------------------------------------------------------------------------------------
-
-
-ostream& operator<<(ostream& dst, const Type& t) { return t->print(dst);}
-
-ostream& operator<<(ostream& dst, const SimpleType& t) { return t.print(dst); }
-
-ostream& operator<<(ostream& dst, const TableType& t) { return t.print(dst); }
-
-ostream& operator<<(ostream& dst, const TupletType& t) { return t.print(dst); }
-
-ostream& operator<<(ostream& dst, const VectorType& t) { return t.print(dst); }
-
-
-//------------------------------------------------------------------------------------
-//
-// Definition des methodes d'impression
-//
-//------------------------------------------------------------------------------------
-
-
-/**
- * Print the content of a simple type on a stream
- */
-ostream& SimpleType::print(ostream& dst) const
-{
- return dst << "NR"[nature()]
- << "KB?S"[variability()]
- << "CI?E"[computability()]
- << "VS?TS"[vectorability()]
- << "N?B"[boolean()]
- << " " << fInterval;
-}
-
-
-/**
- * Print the content of a table type on a stream
- */
-ostream& TableType::print(ostream& dst) const
-{
- dst << "KB?S"[variability()]
- << "CI?E"[computability()]
- << " " << fInterval
- << ":Table(";
- fContent->print(dst);
- return dst << ')';
-}
-
-
-/**
- * true when type is maximal (and therefore can't change depending of hypothesis)
- */
-bool TableType::isMaximal() const
-{
- return (fNature==kReal)
- && (fVariability==kSamp)
- && (fComputability==kExec);
-}
-
-
-
-/**
- * Print the content of a tuplet of types on a stream
- */
-ostream& TupletType::print(ostream& dst) const
-{
- dst << "KB?S"[variability()]
- << "CI?E"[computability()]
- << " " << fInterval
- << " : {";
- string sep = "";
- for (unsigned int i = 0; i < fComponents.size(); i++, sep="*") {
- dst << sep;
- fComponents[i]->print(dst);
- }
- dst << '}';
- return dst;
-}
-
-
-
-/**
- * Print the content of a vector type on a stream
- */
-ostream& VectorType::print(ostream& dst) const
-{
- dst << "vector[" << fSize << "," << fContent << "]";
- return dst;
-}
-
-
-/**
- * true when type is maximal (and therefore can't change depending of hypothesis)
- */
-bool TupletType::isMaximal() const
-{
- for (unsigned int i = 0; i < fComponents.size(); i++) {
- if (! fComponents[i]->isMaximal()) return false;
- }
- return true;
-}
-
-
-//------------------------------------------------------------------------------------
-//
-// Construction des types
-// t := p, table(t), t|t, t*t
-//
-//------------------------------------------------------------------------------------
-
-// Essential predefined types
-
-Type TINT = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
-Type TREAL = makeSimpleType(kReal, kKonst, kComp, kVect, kNum, interval());
-
-Type TKONST = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
-Type TBLOCK = makeSimpleType(kInt, kBlock, kComp, kVect, kNum, interval());
-Type TSAMP = makeSimpleType(kInt, kSamp, kComp, kVect, kNum, interval());
-
-Type TCOMP = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
-Type TINIT = makeSimpleType(kInt, kKonst, kInit, kVect, kNum, interval());
-Type TEXEC = makeSimpleType(kInt, kKonst, kExec, kVect, kNum, interval());
-
-// more predefined types
-
-Type TINPUT = makeSimpleType(kReal, kSamp, kExec, kVect, kNum, interval());
-Type TGUI = makeSimpleType(kReal, kBlock,kExec, kVect, kNum, interval());
-Type TGUI01 = makeSimpleType(kReal, kBlock,kExec, kVect, kNum, interval(0,1));
-Type INT_TGUI = makeSimpleType(kInt, kBlock,kExec, kVect, kNum, interval());
-//Type TREC = makeSimpleType(kInt, kSamp, kInit, kVect, kNum, interval()); // kVect ou kScal ?
-
-// trying to accelerate type convergence
-//Type TREC = TINT;
-Type TREC = makeSimpleType(kInt, kSamp, kInit, kScal, kNum, interval()); // kVect ou kScal ?
-
-
-Type operator| ( const Type& t1, const Type& t2)
-{
- SimpleType *st1, *st2;
- TableType *tt1, *tt2;
- TupletType *nt1, *nt2;
-
- if ( (st1 = isSimpleType(t1)) && (st2 = isSimpleType(t2)) ) {
-
- return makeSimpleType( st1->nature()|st2->nature(),
- st1->variability()|st2->variability(),
- st1->computability()|st2->computability(),
- st1->vectorability()|st2->vectorability(),
- st1->boolean()|st2->boolean(),
- reunion(st1->getInterval(), st2->getInterval())
- );
-
- } else if ( (tt1 = isTableType(t1)) && (tt2 = isTableType(t2)) ) {
-
- return makeTableType( tt1->content() | tt2->content() );
-
- } else if ( (nt1 = isTupletType(t1)) && (nt2 = isTupletType(t2)) ) {
-
- vector<Type> v;
- int n = min(nt1->arity(), nt2->arity());
- for (int i=0; i<n; i++) { v.push_back( (*nt1)[i] | (*nt2)[i]); }
- return new TupletType( v );
-
- } else {
-
- vector<int> D1, D2, D3;
- Type b1 = t1->dimensions(D1);
- Type b2 = t2->dimensions(D2);
- if (maxdimensions(D1, D2, D3)) {
- Type b3 = b1|b2;
- return makeVectorType(b3, D3);
- }
-
- cerr << "Error : trying to combine incompatible types, " << t1 << " and " << t2 << endl;
- exit(1);
- return 0;
- }
-}
-
-bool operator== ( const Type& t1, const Type& t2)
-{
- SimpleType *st1, *st2;
- TableType *tt1, *tt2;
- TupletType *nt1, *nt2;
- VectorType *vt1, *vt2;
-
- if (t1->variability() != t2->variability()) return false;
- if (t1->computability() != t2->computability()) return false;
-
- if ( (st1 = isSimpleType(t1)) && (st2 = isSimpleType(t2)) )
- return (st1->nature() == st2->nature())
- && (st1->variability() == st2->variability())
- && (st1->computability() == st2->computability())
- && (st1->vectorability() == st2->vectorability())
- && (st1->boolean() == st2->boolean())
- && (st1->getInterval().lo == st2->getInterval().lo)
- && (st1->getInterval().hi == st2->getInterval().hi)
- && (st1->getInterval().valid == st2->getInterval().valid);
- if ( (tt1 = isTableType(t1)) && (tt2 = isTableType(t2)) )
- return tt1->content()== tt2->content();
- if ( (nt1 = isTupletType(t1)) && (nt2 = isTupletType(t2)) ) {
- int a1 = nt1->arity();
- int a2 = nt2->arity();
- if (a1 == a2) {
- for (int i=0; i<a1; i++) { if ((*nt1)[i] != (*nt2)[i]) return false; }
- return true;
- } else {
- return false;
- }
- }
-
- // compare vector types
- if ( (vt1 = isVectorType(t1)) && (vt2 = isVectorType(t2)) ) {
- if (vt1->size() == vt2->size()) {
- return vt1->content() == vt2->content();
- } else {
- return false;
- }
- }
-
- // types are different
- return false;
-}
-
-bool operator<= ( const Type& t1, const Type& t2)
-{
- return (t1|t2) == t2;
-}
-
-
-
-Type operator* (const Type& t1, const Type& t2)
-{
- vector<Type> v;
-
- TupletType* nt1 = dynamic_cast<TupletType*>((AudioType*)t1);
- TupletType* nt2 = dynamic_cast<TupletType*>((AudioType*)t2);
-
- if (nt1) {
- for (int i=0; i<nt1->arity(); i++) {
- v.push_back((*nt1)[i]);
- }
- } else {
- v.push_back(t1);
- }
-
- if (nt2) {
- for (int i=0; i<nt2->arity(); i++) {
- v.push_back((*nt2)[i]);
- }
- } else {
- v.push_back(t2);
- }
- return new TupletType(v);
-}
-
-
-SimpleType* isSimpleType(AudioType* t) { return dynamic_cast<SimpleType*>(t); }
-TableType* isTableType(AudioType* t) { return dynamic_cast<TableType*>(t); }
-TupletType* isTupletType(AudioType* t) { return dynamic_cast<TupletType*>(t); }
-VectorType* isVectorType(AudioType* t) { return dynamic_cast<VectorType*>(t); }
-
-
-
-//--------------------------------------------------
-// verification de type
-
-Type checkInt(Type t)
-{
- // verifie que t est entier
- SimpleType* st = isSimpleType(t);
- if (st == 0 || st->nature() > kInt) {
- cerr << "Error : checkInt failed for type " << t << endl;
- exit(1);
- }
- return t;
-}
-
-Type checkKonst(Type t)
-{
- // verifie que t est constant
- if (t->variability() > kKonst) {
- cerr << "Error : checkKonst failed for type " << t << endl;
- exit(1);
- }
- return t;
-}
-
-Type checkInit(Type t)
-{
- // verifie que t est connu a l'initialisation
- if (t->computability() > kInit) {
- cerr << "Error : checkInit failed for type " << t << endl;
- exit(1);
- }
- return t;
-}
-
-Type checkIntParam(Type t)
-{
- return checkInit(checkKonst(checkInt(t)));
-}
-
-Type checkWRTbl(Type tbl, Type wr)
-{
- // verifie que wr est compatible avec le contenu de tbl
- if (wr->nature() > tbl->nature()) {
- cerr << "Error : checkWRTbl failed, the content of " << tbl << " is incompatible with " << wr << endl;
- exit(1);
- }
- return tbl;
-}
-
-/**
- \brief Check is a type is appropriate for a delay.
- @return -1 if not appropriate, mxd (max delay) if appropriate
-
- */
-int checkDelayInterval(Type t)
-{
- interval i = t->getInterval();
- if (i.valid && i.lo >= 0) {
- return int(i.hi+0.5);
- } else {
- //cerr << "checkDelayInterval failed for : " << i << endl;
- return -1;
- }
-}
-
-
-// Donne le nom du type C correspondant �la nature d'un signal
-string cType (Type t)
-{
- return (t->nature() == kInt) ? "int" : "float";
-}
-
-
-
-/*****************************************************************************
- *
- * codeAudioType(Type) -> Tree
- * Code an audio type as a tree in order to benefit of memoization
- *
- *****************************************************************************/
-
-// memoized type contruction
-
-property<AudioType*> MemoizedTypes;
-
-
-Sym SIMPLETYPE = symbol ("SimpleType");
-Sym TABLETYPE = symbol ("TableType");
-Sym TUPLETTYPE = symbol ("TupletType");
-Sym VECTORTYPE = symbol ("VectorType");
-
-static Tree codeSimpleType(SimpleType* st);
-static Tree codeTableType(TableType* st);
-static Tree codeTupletType(TupletType* st);
-static Tree codeVectorType(VectorType* st);
-
-
-/**
- * codeAudioType(Type) -> Tree
- * Code an audio type as a tree in order to benefit of memoization
- * The type field (of the coded type) is used to store the audio
- * type
- */
-Tree codeAudioType(AudioType* t)
-{
- SimpleType* st;
- TableType* tt;
- TupletType* nt;
- VectorType* vt;
-
- Tree r;
-
- if ((r=t->getCode())) return r;
-
- if ((st = isSimpleType(t))) {
- r = codeSimpleType(st);
- } else if ((tt = isTableType(t))) {
- r = codeTableType(tt);
- } else if ((nt = isTupletType(t))) {
- r = codeTupletType(nt);
- } else if ((vt = isVectorType(t))) {
- r = codeVectorType(vt);
- } else {
- cerr << "ERROR in codeAudioType() : invalide pointer " << t << endl;
- exit(1);
- }
-
- r->setType(t);
- return r;
-
-}
-
-
-/**
- * Code a simple audio type as a tree in order to benefit of memoization
- */
-static Tree codeSimpleType(SimpleType* st)
-{
- vector<Tree> elems;
- elems.push_back(tree(st->nature()));
- elems.push_back(tree(st->variability()));
- elems.push_back(tree(st->computability()));
- elems.push_back(tree(st->vectorability()));
- elems.push_back(tree(st->boolean()));
-
- elems.push_back(tree(st->getInterval().valid));
- elems.push_back(tree(st->getInterval().lo));
- elems.push_back(tree(st->getInterval().hi));
-
- return CTree::make(SIMPLETYPE, elems);
-
-}
-
-AudioType* makeSimpleType(int n, int v, int c, int vec, int b, const interval& i)
-{
- SimpleType prototype(n,v,c,vec,b,i);
- Tree code = codeAudioType(&prototype);
-
- AudioType* t;
- if (MemoizedTypes.get(code, t)) {
- return t;
- } else {
- AudioType::gAllocationCount++;
- t = new SimpleType(n,v,c,vec,b,i);
- MemoizedTypes.set(code, t);
- t->setCode(code);
- return t;
- }
-}
-
-
-/**
- * Code a table type as a tree in order to benefit of memoization
- */
-
-static Tree codeTableType(TableType* tt)
-{
- return tree(TABLETYPE, codeAudioType(tt->content()));
-}
-
-AudioType* makeTableType(const Type& ct)
-{
- TableType prototype(ct);
- Tree code = codeAudioType(&prototype);
-
- AudioType* tt;
- if (MemoizedTypes.get(code, tt)) {
- return tt;
- } else {
- AudioType::gAllocationCount++;
- tt = new TableType(ct);
- MemoizedTypes.set(code, tt);
- tt->setCode(code);
- return tt;
- }
-}
-
-AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec, int b, const interval& i)
-{
- TableType prototype(ct,n,v,c,vec,b,i);
- Tree code = codeAudioType(&prototype);
-
- AudioType* tt;
- if (MemoizedTypes.get(code, tt)) {
- return tt;
- } else {
- AudioType::gAllocationCount++;
- tt = new TableType(ct);
- MemoizedTypes.set(code, tt);
- tt->setCode(code);
- return tt;
- }
-}
-
-AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec)
-{
- TableType prototype(ct,n,v,c,vec);
- Tree code = codeAudioType(&prototype);
-
- AudioType* tt;
- if (MemoizedTypes.get(code, tt)) {
- return tt;
- } else {
- AudioType::gAllocationCount++;
- tt = new TableType(ct);
- MemoizedTypes.set(code, tt);
- tt->setCode(code);
- return tt;
- }
-}
-
-
-/**
- * Code a tuplet type as a tree in order to benefit of memoization
- */
-
-static Tree codeTupletType(TupletType* nt)
-{
- vector<Tree> elems;
- for (int i=0; i<nt->arity(); i++) {
- elems.push_back(codeAudioType((*nt)[i]));
- }
- return CTree::make(TUPLETTYPE, elems);
-}
-
-AudioType* makeTupletType(const vector<Type>& vt)
-{
- TupletType prototype(vt);
- Tree code = codeAudioType(&prototype);
-
- AudioType* t;
- if (MemoizedTypes.get(code, t)) {
- return t;
- } else {
- AudioType::gAllocationCount++;
- t = new TupletType(vt);
- MemoizedTypes.set(code, t);
- t->setCode(code);
- return t;
- }
-
-}
-
-AudioType* makeTupletType(const vector<Type>& vt, int n, int v, int c, int vec, int b, const interval& i)
-{
- TupletType prototype(vt,n,v,c,vec,b,i);
- Tree code = codeAudioType(&prototype);
-
- AudioType* t;
- if (MemoizedTypes.get(code, t)) {
- return t;
- } else {
- AudioType::gAllocationCount++;
- t = new TupletType(vt,n,v,c,vec,b,i);
- MemoizedTypes.set(code, t);
- t->setCode(code);
- return t;
- }
-
-}
-
-/**
- * Code a vector type as a tree in order to benefit of memoization
- */
-
-static Tree codeVectorType(VectorType* vt)
-{
- assert(vt);
- //cerr << "codeVectorType(" << *vt << ")" << endl;
- int i = vt->size();
- return tree(VECTORTYPE, tree(i), codeAudioType(vt->content()));
-}
-
-Type makeVectorType(const Type& b, const vector<int>& dim)
-{
- Type r = b;
- for (unsigned int i=0; i<dim.size(); i++) r = new VectorType(dim[i],r);
- return r;
-}
-
-
-/**
- * Returns true if D1 and D2 are compatible (one is the prefix of the other)).
- * In this case D3 contains the longuest vector D1 or D2
- */
-bool maxdimensions(const vector<int>& D1, const vector<int>& D2, vector<int>& D3)
-{
- unsigned int n1 = D1.size();
- unsigned int n2 = D2.size();
- unsigned int i = 0;
- while ( (i<n1) && (i<n2) && (D1[i]==D2[i]) ) i++;
- if (i==n1) {
- D3=D2;
- return true;
- } else if (i==n2) {
- D3=D1;
- return true;
- } else {
- return false;
- }
-}
projects / Faustine.git / blobdiff