--- /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.
+ ************************************************************************
+ ************************************************************************/
+
+
+
+#ifndef _SigType_
+#define _SigType_
+
+#include <vector>
+#include <string>
+#include <iostream>
+#include "tree.hh"
+#include "smartpointer.hh"
+#include "interval.hh"
+
+
+/*********************************************************************
+*
+* Type System for FAUST
+*
+* <type> ::= <simpletype> || table(<type>)
+* || <type>|<type> || <type>*<type>
+* <simpletype> ::= <nature><variability><computability><vectorability>||<boolean>
+* <nature> ::= TINT || TREAL
+* <variability> ::= TKONST || TBLOCK || TSAMP
+* <computability> ::= TCOMP || TINIT || TEXEC
+* <vectorability> ::= KVECT || KSCAL || KTRUESCAL
+* <boolean> ::= 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<AudioType> 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<int>& 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<Type>& 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<Type>& 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<Type>& 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<Type>& 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<Type>& 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<Type>& 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<Type>& vt);
+AudioType* makeTupletType(const vector<Type>& 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<int>& 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<int>& 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<Type> fComponents;
+
+ public:
+ TupletType() :
+ AudioType(0,0,0)
+ {}
+
+ TupletType(const vector<Type>& vt) :
+ AudioType(mergenature(vt),mergevariability(vt),mergecomputability(vt),mergevectorability(vt),mergeboolean(vt), mergeinterval(vt)),
+ fComponents(vt) {}
+
+ TupletType(const vector<Type>& 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<int>& 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<int>& D) { AudioType* t = fContent->dimensions(D); D.push_back(fSize); return t;} ///< vectors have a dimension
+
+
+};
+
+Type makeVectorType(const Type& b, const vector<int>& dim);
+bool maxdimensions(const vector<int>& D1, const vector<int>& D2, vector<int>& 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<t1; }
+inline bool operator>=(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
projects / Faustine.git / blobdiff