X-Git-Url: https://scm.cri.ensmp.fr/git/Faustine.git/blobdiff_plain/1059e1cc0c2ecfa237406949aa26155b6a5b9154..66f23d4fabf89ad09adbd4dfc15ac6b5b2b7da83:/interpreter/preprocessor/faust-0.9.47mr3/compiler/signals/sigtype.hh diff --git a/interpreter/preprocessor/faust-0.9.47mr3/compiler/signals/sigtype.hh b/interpreter/preprocessor/faust-0.9.47mr3/compiler/signals/sigtype.hh new file mode 100644 index 0000000..2d4694c --- /dev/null +++ b/interpreter/preprocessor/faust-0.9.47mr3/compiler/signals/sigtype.hh @@ -0,0 +1,519 @@ +/************************************************************************ + ************************************************************************ + 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. + ************************************************************************ + ************************************************************************/ + + + +#ifndef _SigType_ +#define _SigType_ + +#include +#include +#include +#include "tree.hh" +#include "smartpointer.hh" +#include "interval.hh" + + +/********************************************************************* +* +* Type System for FAUST +* +* ::= || table() +* || | || * +* ::= || +* ::= TINT || TREAL +* ::= TKONST || TBLOCK || TSAMP +* ::= TCOMP || TINIT || TEXEC +* ::= KVECT || KSCAL || KTRUESCAL +* ::= KNUM || KBOOL +* +**********************************************************************/ + + +//-------------------------------------------------- +// qualite des types simples + +enum { kInt = 0, kReal = 1 }; ///< nature : integer or floating point values +enum { kNum = 0 , kBool = 1}; ///< boolean : when a signal stands for a boolean value ( while being of c-type int or float ) +enum { kKonst = 0, kBlock = 1, kSamp = 3 }; ///< variability : how fast values change +enum { kComp = 0, kInit = 1, kExec = 3 }; ///< computability : when values are available +enum { kVect = 0, kScal = 1, kTrueScal = 3/*, kIndex = 4*/};///< vectorability: when a signal can be vectorized ( actually, only kVect and kScal matter; kTrueScal and kIndex don't denote types but are here to simplify code generation ) + +/*--------------------------------------------------------------------- + + AbstractType : + The root class for SimpleType, TableType and TupletType + + Type : + A smartPointer to type + +----------------------------------------------------------------------*/ + +using namespace std; + +class AudioType; + +typedef P Type; + +/** + * The Root class for all audio data types. + * All audio types have a "variability" (how fast the values change) and + * a "computability" (when the values are available). Simple types have + * also a "nature" (integer or floating point). + */ +class AudioType +{ + public: + static int gAllocationCount; + protected: + int fNature; ///< the kind of data represented + int fVariability; ///< how fast values change + int fComputability; ///< when are values available + int fVectorability; ///< when a signal can be vectorized + int fBoolean; ///< when a signal stands for a boolean value + + interval fInterval; ///< Minimal and maximal values the signal can take + Tree fCode; ///< Tree representation (for memoization purposes) + + + public : + AudioType(int n, int v, int c, int vec = kVect, int b = kNum, interval i=interval()) + : fNature(n), fVariability(v), fComputability(c), + fVectorability(vec), fBoolean(b), + fInterval(i), fCode(0) {} ///< constructs an abstract audio type + + virtual ~AudioType() {} ///< not really useful here, but make compiler happier + + int nature() const { return fNature; } ///< returns the kind of values (integre or floating point) + int variability() const { return fVariability; } ///< returns how fast values change (constant, by blocks, by samples) + int computability() const { return fComputability;} ///< returns when values are available (compilation, initialisation, execution) + int vectorability() const { return fVectorability;} ///< returns when a signal can be vectorized + int boolean() const { return fBoolean; } ///< returns when a signal stands for a boolean value + + interval getInterval() const { return fInterval; } ///< returns the interval (min dn max values) of a signal + + void setCode(Tree code) { fCode = code; } ///< returns the interval (min dn max values) of a signal + Tree getCode() { return fCode; } ///< returns the interval (min dn max values) of a signal + + + + virtual AudioType* promoteNature(int n) = 0; ///< promote the nature of a type + virtual AudioType* promoteVariability(int n) = 0; ///< promote the variability of a type + virtual AudioType* promoteComputability(int n) = 0; ///< promote the computability of a type + virtual AudioType* promoteVectorability(int n) = 0; ///< promote the vectorability of a type + virtual AudioType* promoteBoolean(int n) = 0; ///< promote the booleanity of a type + //virtual AudioType* promoteInterval(const interval& i) = 0; ///< promote the interval of a type + + + virtual ostream& print(ostream& dst) const = 0; ///< print nicely a type + virtual bool isMaximal() const = 0; ///< true when type is maximal (and therefore can't change depending of hypothesis) + + virtual AudioType* dimensions(vector& D) = 0; /// Fill D with the dimensions of the type and returns its base type + + protected: + void setInterval(const interval& r) { fInterval = r;} + +}; + +//printing +inline ostream& operator << (ostream& s, const AudioType& n) { return n.print(s); } + + +/** + * Return the nature of a vector of types. + */ +inline int mergenature(const vector& v) +{ + int r = 0; + for (unsigned int i = 0; i < v.size(); i++) r |= v[i]->nature(); + return r; +} + + + +/** + * Return the variability of a vector of types. + */ +inline int mergevariability(const vector& v) +{ + int r = 0; + for (unsigned int i = 0; i < v.size(); i++) r |= v[i]->variability(); + return r; +} + + + +/** + * Return the computability of a vector of types. + */ +inline int mergecomputability(const vector& v) +{ + int r = 0; + for (unsigned int i = 0; i < v.size(); i++) r |= v[i]->computability(); + return r; +} + + + +/** + * Return the vectorability of a vector of types. + */ +inline int mergevectorability(const vector& v) +{ + int r = 0; + for (unsigned int i = 0; i < v.size(); i++) r |= v[i]->vectorability(); + return r; +} + + + +/** + * Return the booleanity of a vector of types. + */ +inline int mergeboolean(const vector& v) +{ + int r = 0; + for (unsigned int i = 0; i < v.size(); i++) r |= v[i]->boolean(); + return r; +} + + + +/** + * Return the interval of a vector of types. + */ +inline interval mergeinterval(const vector& v) +{ + if (v.size()==0) { + return interval(); + } else { + double lo=0, hi=0; + for (unsigned int i = 0; i < v.size(); i++) { + interval r = v[i]->getInterval(); + if (!r.valid) return r; + if (i==0) { + lo = r.lo; + hi = r.hi; + } else { + lo = min(lo,r.lo); + hi = max(hi,r.hi); + } + } + return interval(lo, hi); + } +} + + +AudioType* makeSimpleType(int n, int v, int c, int vec, int b, const interval& i); + +AudioType* makeTableType(const Type& ct); +AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec); +AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec, int b, const interval& i); + + +AudioType* makeTupletType(const vector& vt); +AudioType* makeTupletType(const vector& vt, int n, int v, int c, int vec, int b, const interval& i); + +/** + * The type of a simple numeric audio signal. + * Beside a computability and a variability, SimpleTypes have + * a "nature" indicating if they represent an integer or floating + * point audio signals. + */ +class SimpleType : public AudioType +{ + public : + + SimpleType(int n, int v, int c, int vec, int b, const interval& i) : AudioType(n,v,c,vec,b,i) { + //cerr << "new simple type " << i << " -> " << *this << endl; + } ///< constructs a SimpleType from a nature a variability and a computability + + virtual ostream& print(ostream& dst) const; ///< print a SimpleType + + + + virtual AudioType* promoteNature(int n) { return makeSimpleType(n|fNature, fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the nature of a type + virtual AudioType* promoteVariability(int v) { return makeSimpleType(fNature, v|fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the variability of a type + virtual AudioType* promoteComputability(int c) { return makeSimpleType(fNature, fVariability, c|fComputability, fVectorability, fBoolean, fInterval); } ///< promote the computability of a type + virtual AudioType* promoteVectorability(int vec) { return makeSimpleType(fNature, fVariability, fComputability, vec|fVectorability, fBoolean, fInterval); } ///< promote the vectorability of a type + virtual AudioType* promoteBoolean(int b) { return makeSimpleType(fNature, fVariability, fComputability, fVectorability, b|fBoolean, fInterval); } ///< promote the booleanity of a type +// virtual AudioType* promoteInterval(const interval& i) { +// cerr << "promote to Interval " << i << endl; +// cerr << "for type : " << *this << endl; +// Type t = makeSimpleType(fNature, fVariability, fComputability, fVectorability, fBoolean, i); ///< promote the interval of a type +// cerr << "gives type " << *t << endl; +// return t; +// } + virtual AudioType* dimensions(vector& D) { D.clear(); return this; } // scalar have no dimensions + + virtual bool isMaximal() const; ///< true when type is maximal (and therefore can't change depending of hypothesis) + + + +}; + +inline Type intCast (Type t) { return makeSimpleType(kInt, t->variability(), t->computability(), t->vectorability(), t->boolean(), t->getInterval()); } +inline Type floatCast (Type t) { return makeSimpleType(kReal, t->variability(), t->computability(), t->vectorability(), t->boolean(), t->getInterval()); } +inline Type sampCast (Type t) { return makeSimpleType(t->nature(), kSamp, t->computability(), t->vectorability(), t->boolean(), t->getInterval()); } +inline Type boolCast (Type t) { return makeSimpleType(t->nature(), t->variability(), t->computability(), t->vectorability(), kBool, t->getInterval()); } +inline Type numCast (Type t) { return makeSimpleType(t->nature(), t->variability(), t->computability(), t->vectorability(), kNum, t->getInterval()); } +inline Type vecCast (Type t) { return makeSimpleType(t->nature(), t->variability(), t->computability(), kVect, t->boolean(), t->getInterval()); } +inline Type scalCast (Type t) { return makeSimpleType(t->nature(), t->variability(), t->computability(), kScal, t->boolean(), t->getInterval()); } +inline Type truescalCast (Type t){ return makeSimpleType(t->nature(), t->variability(), t->computability(), kTrueScal, t->boolean(), t->getInterval()); } + +inline Type castInterval (Type t, const interval& i) +{ + return makeSimpleType(t->nature(), t->variability(), t->computability(), t->vectorability(), t->boolean(), i); +} + +/** + * The type of a table of audio data. + * Beside a computability and a variability, TableTypes have + * a "content" indicating the type of the data stored in the table. + */ +class TableType : public AudioType +{ + protected : + const Type fContent; ///< type of that data stored in the table + + public : + TableType(const Type& t) : + AudioType(t->nature(), t->variability(), t->computability(), t->vectorability(), t->boolean()), + fContent(t) {} ///< construct a TableType with a content of a type t +#if 0 + TableType(const Type& t, int v, int c) : + AudioType(t->nature(), t->variability()|v, t->computability()|c, t->vectorability(), t->boolean()), + fContent(t) {} ///< construct a TableType with a content of a type t, promoting variability and computability + + TableType(const Type& t, int n, int v, int c) : + AudioType(t->nature()|n, t->variability()|v, t->computability()|c, t->vectorability(), t->boolean()), + fContent(t) {} ///< construct a TableType with a content of a type t, promoting nature, variability and computability + + TableType(const Type& t, int n, int v, int c, int vec, int b) : + AudioType(t->nature()|n, t->variability()|v, t->computability()|c, t->vectorability()|vec, t->boolean()|b), + fContent(t) {} ///< construct a TableType with a content of a type t, promoting nature, variability, computability, vectorability and booleanity +#endif + + TableType(const Type& t, int n, int v, int c, int vec, int b, const interval& i) : + AudioType(t->nature()|n, t->variability()|v, t->computability()|c, t->vectorability()|vec, t->boolean()|b, i), + fContent(t) {} ///< construct a TableType with a content of a type t, promoting nature, variability, computability, vectorability and booleanity + + TableType(const Type& t, int n, int v, int c, int vec) : + AudioType(t->nature()|n, t->variability()|v, t->computability()|c, t->vectorability()|vec, t->boolean()), + fContent(t) {} ///< construct a TableType with a content of a type t, promoting nature, variability, computability and vectorability + + + Type content() const { return fContent; } ///< return the type of data store in the table + virtual ostream& print(ostream& dst) const; ///< print a TableType + + virtual AudioType* promoteNature(int n) { return makeTableType(fContent, n|fNature, fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the nature of a type + virtual AudioType* promoteVariability(int v) { return makeTableType(fContent, fNature, v|fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the variability of a type + virtual AudioType* promoteComputability(int c) { return makeTableType(fContent, fNature, fVariability, c|fComputability, fVectorability, fBoolean, fInterval); } ///< promote the computability of a type + virtual AudioType* promoteVectorability(int vec) { return makeTableType(fContent, fNature, fVariability, fComputability, vec|fVectorability, fBoolean, fInterval);}///< promote the vectorability of a type + virtual AudioType* promoteBoolean(int b) { return makeTableType(fContent, fNature, fVariability, fComputability, fVectorability, b|fBoolean, fInterval); } ///< promote the booleanity of a type + //virtual AudioType* promoteInterval(const interval& i) { return makeTableType(fContent, fNature, fVariability, fComputability, fVectorability, fBoolean, i); } ///< promote the interval of a type + + virtual bool isMaximal() const; ///< true when type is maximal (and therefore can't change depending of hypothesis) + + virtual AudioType* dimensions(vector& D) { D.clear(); return this; } // tables have no dimensions + +}; + + + +/** + * The type of a tuplet of data. + * Beside a computability and a variability, TupletTypes have + * a set of components. + */ +class TupletType : public AudioType +{ + protected: + vector fComponents; + + public: + TupletType() : + AudioType(0,0,0) + {} + + TupletType(const vector& vt) : + AudioType(mergenature(vt),mergevariability(vt),mergecomputability(vt),mergevectorability(vt),mergeboolean(vt), mergeinterval(vt)), + fComponents(vt) {} + + TupletType(const vector& vt, int n, int v, int c, int vec, int b, const interval& i) : + AudioType(n|mergenature(vt), v|mergevariability(vt), c|mergecomputability(vt), vec|mergevectorability(vt), b|mergeboolean(vt), i), + fComponents(vt) {} + + int arity() const { return fComponents.size(); } + Type operator[](unsigned int i) const { return fComponents[i]; } + virtual ostream& print(ostream& dst) const; + + virtual AudioType* promoteNature(int n) { return new TupletType(fComponents, n|fNature, fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the nature of a type + virtual AudioType* promoteVariability(int v) { return new TupletType(fComponents, fNature, v|fVariability, fComputability, fVectorability, fBoolean, fInterval); } ///< promote the variability of a type + virtual AudioType* promoteComputability(int c) { return new TupletType(fComponents, fNature, fVariability, c|fComputability, fVectorability, fBoolean, fInterval); } ///< promote the computability of a type + virtual AudioType* promoteVectorability(int vec) { return new TupletType(fComponents, fNature, fVariability, fComputability, vec|fVectorability, fBoolean, fInterval);} ///< promote the vectorability of a type + virtual AudioType* promoteBoolean(int b) { return new TupletType(fComponents, fNature, fVariability, fComputability, fVectorability, b|fBoolean, fInterval); } ///< promote the booleanity of a type + //virtual AudioType* promoteInterval(const interval& i) { return new TupletType(fComponents, fNature, fVariability, fComputability, fVectorability, fBoolean, i); } ///< promote the interval of a type + + virtual bool isMaximal() const; ///< true when type is maximal (and therefore can't change depending of hypothesis) + virtual AudioType* dimensions(vector& D) { D.clear(); return this; } // tuples have no dimensions + +}; + + + +/** + * The type T = vector(n, T') of a signal of vectors of fixed size n and elements of type T' + * The following properties hold : + * nature(vector(n,T')) = nature(T') + * variability(vector(n,T')) = variability(T') + * computability(vector(n,T')) = computability(T') + * vectorability(vector(n,T')) = ??? (so probably no) + * boolean(vector(n,T')) = false (a vector is not a boolean) + * getInterval(vector(n,T')) = getInterval(T') (is it meanuful ?) + */ +class VectorType : public AudioType +{ + protected: + int fSize; ///< size of the vector + Type fContent; ///< type of the elements + + public: + VectorType(int n, const Type& t) : AudioType(t->nature(), t->variability(), t->computability(), t->vectorability(), + t->boolean(), t->getInterval()), + fSize(n), + fContent(t) + {} + + + int size() const { return fSize; } + Type content() const { return fContent; } + + virtual ostream& print(ostream& dst) const; + + virtual AudioType* promoteNature(int n) { return new VectorType(fSize, fContent->promoteNature(n)); } ///< promote the nature of a type + virtual AudioType* promoteVariability(int v) { return new VectorType(fSize, fContent->promoteVariability(v)); } ///< promote the variability of a type + virtual AudioType* promoteComputability(int c) { return new VectorType(fSize, fContent->promoteComputability(c)); } ///< promote the computability of a type + virtual AudioType* promoteVectorability(int vec) { return new VectorType(fSize, fContent->promoteVectorability(vec)); } ///< promote the vectorability of a type + virtual AudioType* promoteBoolean(int b) { return new VectorType(fSize, fContent->promoteBoolean(b)); } ///< promote the booleanity of a type + virtual bool isMaximal() const { return false; } ///< true when type is maximal (and therefore can't change depending of hypothesis) + virtual AudioType* dimensions(vector& D) { AudioType* t = fContent->dimensions(D); D.push_back(fSize); return t;} ///< vectors have a dimension + + +}; + +Type makeVectorType(const Type& b, const vector& dim); +bool maxdimensions(const vector& D1, const vector& D2, vector& D3); + + + + +//------------------------------------------------- +//------------------------------------------------- +// operations sur les types +//------------------------------------------------- +//------------------------------------------------- + + + +//-------------------------------------------------- +// liste de types predefinis + +extern Type TINT; +extern Type TREAL; + +extern Type TKONST; +extern Type TBLOCK; +extern Type TSAMP; + +extern Type TCOMP; +extern Type TINIT; +extern Type TEXEC; + +extern Type TINPUT; +extern Type TGUI; +extern Type TGUI01; +extern Type INT_TGUI; +extern Type TREC; + + +//-------------------------------------------------- +// creation de types + +Type table (const Type& t); +Type operator| (const Type& t1, const Type& t2); +Type operator* (const Type& t1, const Type& t2); + + +//-------------------------------------------------- +// comparaison de types + +bool operator==(const Type& t1, const Type& t2); +bool operator<=(const Type& t1, const Type& t2); + +inline bool operator!=(const Type& t1, const Type& t2) { return !(t1==t2); } +inline bool operator< (const Type& t1, const Type& t2) { return t1<=t2 && t1!=t2; } +inline bool operator> (const Type& t1, const Type& t2) { return t2=(const Type& t1, const Type& t2) { return t2<=t1; } + + +//-------------------------------------------------- +// predicats-conversion de types + +SimpleType* isSimpleType (AudioType* t); +TableType* isTableType (AudioType* t); +TupletType* isTupletType (AudioType* t); +VectorType* isVectorType (AudioType* t); + + +//-------------------------------------------------- +// impressions de types + +ostream& operator<<(ostream& dst, const SimpleType& t); +ostream& operator<<(ostream& dst, const Type& t); +ostream& operator<<(ostream& dst, const TableType& t); +ostream& operator<<(ostream& dst, const TupletType& t); +ostream& operator<<(ostream& dst, const VectorType& t); + + +//-------------------------------------------------- +// verification de type + +Type checkInt(Type t); ///< verifie que t est entier +Type checkKonst(Type t); ///< verifie que t est constant +Type checkInit(Type t); ///< verifie que t est connu a l'initialisation + +Type checkIntParam(Type t); ///< verifie que t est connu a l'initialisation, constant et entier + +Type checkWRTbl(Type tbl, Type wr); ///< verifie que wr est compatible avec le contenu de tbl + +int checkDelayInterval(Type t); ///< Check if the interval of t is appropriate for a delay + + +//-------------------------------------------------- +// conversion de type + +string cType (Type t); + +Tree codeAudioType(AudioType* t); ///< Code an audio type as a tree (memoization) + + +#endif