interpretor/preprocessor/faust-0.9.47mr3/compiler/signals/sigtype.cpp

   1 /************************************************************************
   2  ************************************************************************
   3     FAUST compiler
   4         Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
   5     ---------------------------------------------------------------------
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  ************************************************************************
  20  ************************************************************************/
  21
  22
  23
  24 #include "tree.hh"
  25 #include "sigtype.hh"
  26 #include "property.hh"
  27
  28 int     AudioType::gAllocationCount = 0;
  29
  30 bool    SimpleType::isMaximal() const                             ///< true when type is maximal (and therefore can't change depending of hypothesis)
  31 {
  32     return  (fNature==kReal)
  33             && (fVariability==kSamp)
  34             && (fComputability==kExec);
  35
  36 }
  37
  38
  39 //------------------------------------------------------------------------------------
  40 //
  41 //              Surcharges de l'operateur d'impression <<
  42 //
  43 //------------------------------------------------------------------------------------
  44
  45
  46 ostream& operator<<(ostream& dst, const Type& t)        { return  t->print(dst);}
  47
  48 ostream& operator<<(ostream& dst, const SimpleType& t)  { return  t.print(dst); }
  49
  50 ostream& operator<<(ostream& dst, const TableType& t)   { return  t.print(dst); }
  51
  52 ostream& operator<<(ostream& dst, const TupletType& t)  { return  t.print(dst); }
  53
  54 ostream& operator<<(ostream& dst, const VectorType& t)  { return  t.print(dst); }
  55
  56
  57 //------------------------------------------------------------------------------------
  58 //
  59 //              Definition des methodes d'impression
  60 //
  61 //------------------------------------------------------------------------------------
  62
  63
  64 /**
  65  * Print the content of a simple type on a stream
  66  */
  67 ostream& SimpleType::print(ostream& dst) const
  68 {
  69         return  dst << "NR"[nature()]
  70                     << "KB?S"[variability()]
  71                     << "CI?E"[computability()]
  72                     << "VS?TS"[vectorability()]
  73                     << "N?B"[boolean()]
  74                         << " " << fInterval;
  75 }
  76
  77
  78 /**
  79  * Print the content of a table type on a stream
  80  */
  81 ostream& TableType::print(ostream& dst) const
  82 {
  83         dst << "KB?S"[variability()]
  84                 << "CI?E"[computability()]
  85                 << " " << fInterval
  86                 << ":Table(";
  87         fContent->print(dst);
  88         return dst << ')';
  89 }
  90
  91
  92 /**
  93  *  true when type is maximal (and therefore can't change depending of hypothesis)
  94  */
  95 bool    TableType::isMaximal() const
  96 {
  97     return  (fNature==kReal)
  98             && (fVariability==kSamp)
  99             && (fComputability==kExec);
 100 }
 101
 102
 103
 104 /**
 105  * Print the content of a tuplet of types on a stream
 106  */
 107 ostream& TupletType::print(ostream& dst) const
 108 {
 109     dst << "KB?S"[variability()]
 110         << "CI?E"[computability()]
 111         << " " << fInterval
 112         << " : {";
 113     string sep = "";
 114     for (unsigned int i = 0; i < fComponents.size(); i++, sep="*") {
 115         dst << sep;
 116         fComponents[i]->print(dst);
 117     }
 118     dst << '}';
 119     return  dst;
 120 }
 121
 122
 123
 124 /**
 125  * Print the content of a vector type on a stream
 126  */
 127 ostream& VectorType::print(ostream& dst) const
 128 {
 129     dst << "vector[" << fSize << "," << fContent << "]";
 130     return dst;
 131 }
 132
 133
 134 /**
 135  *  true when type is maximal (and therefore can't change depending of hypothesis)
 136  */
 137 bool TupletType::isMaximal() const
 138 {
 139     for (unsigned int i = 0; i < fComponents.size(); i++) {
 140         if (! fComponents[i]->isMaximal()) return false;
 141     }
 142     return true;
 143 }
 144
 145
 146 //------------------------------------------------------------------------------------
 147 //
 148 //              Construction des types
 149 //              t := p, table(t), t|t, t*t
 150 //
 151 //------------------------------------------------------------------------------------
 152
 153 // Essential predefined types
 154
 155 Type TINT       = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
 156 Type TREAL      = makeSimpleType(kReal, kKonst, kComp, kVect, kNum, interval());
 157
 158 Type TKONST = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
 159 Type TBLOCK = makeSimpleType(kInt, kBlock, kComp, kVect, kNum, interval());
 160 Type TSAMP      = makeSimpleType(kInt, kSamp, kComp, kVect, kNum, interval());
 161
 162 Type TCOMP      = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval());
 163 Type TINIT      = makeSimpleType(kInt, kKonst, kInit, kVect, kNum, interval());
 164 Type TEXEC      = makeSimpleType(kInt, kKonst, kExec, kVect, kNum, interval());
 165
 166 // more predefined types
 167
 168 Type TINPUT     = makeSimpleType(kReal, kSamp, kExec, kVect, kNum, interval());
 169 Type TGUI       = makeSimpleType(kReal, kBlock,kExec, kVect, kNum, interval());
 170 Type TGUI01     = makeSimpleType(kReal, kBlock,kExec, kVect, kNum, interval(0,1));
 171 Type INT_TGUI   = makeSimpleType(kInt,  kBlock,kExec, kVect, kNum, interval());
 172 //Type TREC   = makeSimpleType(kInt,  kSamp, kInit, kVect, kNum, interval()); // kVect ou kScal ?
 173
 174 // trying to accelerate type convergence
 175 //Type TREC   = TINT;
 176 Type TREC   = makeSimpleType(kInt, kSamp, kInit, kScal, kNum, interval()); // kVect ou kScal ?
 177
 178
 179 Type operator| ( const Type& t1, const Type& t2)
 180 {
 181         SimpleType      *st1, *st2;
 182         TableType       *tt1, *tt2;
 183         TupletType      *nt1, *nt2;
 184
 185         if ( (st1 = isSimpleType(t1)) && (st2 = isSimpleType(t2)) ) {
 186
 187         return makeSimpleType(  st1->nature()|st2->nature(),
 188                                         st1->variability()|st2->variability(),
 189                                         st1->computability()|st2->computability(),
 190                                         st1->vectorability()|st2->vectorability(),
 191                                         st1->boolean()|st2->boolean(),
 192                     reunion(st1->getInterval(), st2->getInterval())
 193                                         );
 194
 195         } else if ( (tt1 = isTableType(t1)) && (tt2 = isTableType(t2)) ) {
 196
 197         return makeTableType( tt1->content() | tt2->content() );
 198
 199         } else if ( (nt1 = isTupletType(t1)) && (nt2 = isTupletType(t2)) ) {
 200
 201                 vector<Type> v;
 202                 int n = min(nt1->arity(), nt2->arity());
 203                 for (int i=0; i<n; i++) { v.push_back( (*nt1)[i] | (*nt2)[i]); }
 204                 return new TupletType( v );
 205
 206         } else {
 207
 208         vector<int> D1, D2, D3;
 209         Type  b1 = t1->dimensions(D1);
 210         Type  b2 = t2->dimensions(D2);
 211         if (maxdimensions(D1, D2, D3)) {
 212             Type b3 = b1|b2;
 213             return makeVectorType(b3, D3);
 214         }
 215
 216                 cerr << "Error : trying to combine incompatible types, " << t1 << " and " << t2 << endl;
 217                 exit(1);
 218                 return 0;
 219         }
 220 }
 221
 222 bool operator== ( const Type& t1, const Type& t2)
 223 {
 224         SimpleType      *st1, *st2;
 225         TableType       *tt1, *tt2;
 226     TupletType  *nt1, *nt2;
 227     VectorType  *vt1, *vt2;
 228
 229         if (t1->variability() != t2->variability())     return false;
 230         if (t1->computability() != t2->computability()) return false;
 231
 232     if ( (st1 = isSimpleType(t1)) && (st2 = isSimpleType(t2)) )
 233         return     (st1->nature() == st2->nature())
 234                 && (st1->variability() == st2->variability())
 235                 && (st1->computability() == st2->computability())
 236                 && (st1->vectorability() == st2->vectorability())
 237                 && (st1->boolean() == st2->boolean())
 238                 && (st1->getInterval().lo == st2->getInterval().lo)
 239                 && (st1->getInterval().hi == st2->getInterval().hi)
 240                 && (st1->getInterval().valid == st2->getInterval().valid);
 241     if ( (tt1 = isTableType(t1)) && (tt2 = isTableType(t2)) )
 242         return tt1->content()== tt2->content();
 243         if ( (nt1 = isTupletType(t1)) && (nt2 = isTupletType(t2)) ) {
 244                 int a1 = nt1->arity();
 245                 int a2 = nt2->arity();
 246                 if (a1 == a2) {
 247                         for (int i=0; i<a1; i++)  { if ((*nt1)[i] != (*nt2)[i]) return false; }
 248                         return true;
 249                 } else {
 250                         return false;
 251                 }
 252         }
 253
 254     // compare vector types
 255     if ( (vt1 = isVectorType(t1)) && (vt2 = isVectorType(t2)) ) {
 256         if (vt1->size() == vt2->size()) {
 257             return vt1->content() == vt2->content();
 258         } else {
 259             return false;
 260         }
 261     }
 262
 263     // types are different
 264         return false;
 265 }
 266
 267 bool operator<= ( const Type& t1, const Type& t2)
 268 {
 269         return (t1|t2) == t2;
 270 }
 271
 272
 273
 274 Type operator*  (const Type& t1, const Type& t2)
 275 {
 276         vector<Type>    v;
 277
 278         TupletType* nt1 = dynamic_cast<TupletType*>((AudioType*)t1);
 279         TupletType* nt2 = dynamic_cast<TupletType*>((AudioType*)t2);
 280
 281         if (nt1) {
 282                 for (int i=0; i<nt1->arity(); i++) {
 283                         v.push_back((*nt1)[i]);
 284                 }
 285         } else {
 286                 v.push_back(t1);
 287         }
 288
 289         if (nt2) {
 290                 for (int i=0; i<nt2->arity(); i++) {
 291                         v.push_back((*nt2)[i]);
 292                 }
 293         } else {
 294                 v.push_back(t2);
 295         }
 296         return new TupletType(v);
 297 }
 298
 299
 300 SimpleType*     isSimpleType(AudioType* t)      { return dynamic_cast<SimpleType*>(t); }
 301 TableType*      isTableType(AudioType* t)       { return dynamic_cast<TableType*>(t);  }
 302 TupletType*     isTupletType(AudioType* t)      { return dynamic_cast<TupletType*>(t); }
 303 VectorType* isVectorType(AudioType* t)  { return dynamic_cast<VectorType*>(t); }
 304
 305
 306
 307 //--------------------------------------------------
 308 // verification de type
 309
 310 Type checkInt(Type t)
 311 {
 312         // verifie que t est entier
 313         SimpleType* st = isSimpleType(t);
 314         if (st == 0 || st->nature() > kInt) {
 315                 cerr << "Error : checkInt failed for type " << t << endl;
 316                 exit(1);
 317         }
 318         return t;
 319 }
 320
 321 Type checkKonst(Type t)
 322 {
 323         // verifie que t est constant
 324         if (t->variability() > kKonst) {
 325                 cerr << "Error : checkKonst failed for type " << t << endl;
 326                 exit(1);
 327         }
 328         return t;
 329 }
 330
 331 Type checkInit(Type t)
 332 {
 333         // verifie que t est connu a l'initialisation
 334         if (t->computability() > kInit) {
 335                 cerr << "Error : checkInit failed for type " << t << endl;
 336                 exit(1);
 337         }
 338         return t;
 339 }
 340
 341 Type checkIntParam(Type t)
 342 {
 343         return checkInit(checkKonst(checkInt(t)));
 344 }
 345
 346 Type checkWRTbl(Type tbl, Type wr)
 347 {
 348         // verifie que wr est compatible avec le contenu de tbl
 349         if (wr->nature() > tbl->nature()) {
 350                 cerr << "Error : checkWRTbl failed, the content of  " << tbl << " is incompatible with " << wr << endl;
 351                 exit(1);
 352         }
 353         return tbl;
 354 }
 355
 356 /**
 357         \brief Check is a type is appropriate for a delay.
 358         @return -1 if not appropriate, mxd (max delay) if appropriate
 359
 360  */
 361 int checkDelayInterval(Type t)
 362 {
 363         interval i = t->getInterval();
 364         if (i.valid && i.lo >= 0) {
 365                 return int(i.hi+0.5);
 366         } else {
 367                 //cerr << "checkDelayInterval failed for : " << i << endl;
 368                 return -1;
 369         }
 370 }
 371
 372
 373 // Donne le nom du type C correspondant �la nature d'un signal
 374 string cType (Type t)
 375 {
 376         return (t->nature() == kInt) ? "int" : "float";
 377 }
 378
 379
 380
 381 /*****************************************************************************
 382  *
 383  *      codeAudioType(Type) -> Tree
 384  *      Code an audio type as a tree in order to benefit of memoization
 385  *
 386  *****************************************************************************/
 387
 388 // memoized type contruction
 389
 390 property<AudioType*> MemoizedTypes;
 391
 392
 393 Sym SIMPLETYPE = symbol ("SimpleType");
 394 Sym TABLETYPE = symbol ("TableType");
 395 Sym TUPLETTYPE = symbol ("TupletType");
 396 Sym VECTORTYPE = symbol ("VectorType");
 397
 398 static Tree  codeSimpleType(SimpleType* st);
 399 static Tree  codeTableType(TableType* st);
 400 static Tree  codeTupletType(TupletType* st);
 401 static Tree  codeVectorType(VectorType* st);
 402
 403
 404 /**
 405  * codeAudioType(Type) -> Tree
 406  * Code an audio type as a tree in order to benefit of memoization
 407  * The type field (of the coded type) is used to store the audio
 408  * type
 409  */
 410 Tree codeAudioType(AudioType* t)
 411 {
 412     SimpleType*     st;
 413     TableType*      tt;
 414     TupletType*     nt;
 415     VectorType*     vt;
 416
 417     Tree        r;
 418
 419     if ((r=t->getCode())) return r;
 420
 421     if ((st = isSimpleType(t))) {
 422         r = codeSimpleType(st);
 423     } else if ((tt = isTableType(t))) {
 424         r = codeTableType(tt);
 425     } else if ((nt = isTupletType(t))) {
 426         r = codeTupletType(nt);
 427     } else if ((vt = isVectorType(t))) {
 428         r = codeVectorType(vt);
 429     } else {
 430         cerr << "ERROR in codeAudioType() : invalide pointer " << t << endl;
 431         exit(1);
 432     }
 433
 434     r->setType(t);
 435     return r;
 436
 437 }
 438
 439
 440 /**
 441  * Code a simple audio type as a tree in order to benefit of memoization
 442  */
 443 static Tree  codeSimpleType(SimpleType* st)
 444 {
 445     vector<Tree> elems;
 446     elems.push_back(tree(st->nature()));
 447     elems.push_back(tree(st->variability()));
 448     elems.push_back(tree(st->computability()));
 449     elems.push_back(tree(st->vectorability()));
 450     elems.push_back(tree(st->boolean()));
 451
 452     elems.push_back(tree(st->getInterval().valid));
 453     elems.push_back(tree(st->getInterval().lo));
 454     elems.push_back(tree(st->getInterval().hi));
 455
 456     return CTree::make(SIMPLETYPE, elems);
 457
 458 }
 459
 460 AudioType* makeSimpleType(int n, int v, int c, int vec, int b, const interval& i)
 461 {
 462     SimpleType  prototype(n,v,c,vec,b,i);
 463     Tree        code = codeAudioType(&prototype);
 464
 465     AudioType*  t;
 466     if (MemoizedTypes.get(code, t)) {
 467         return t;
 468     } else {
 469         AudioType::gAllocationCount++;
 470         t = new SimpleType(n,v,c,vec,b,i);
 471         MemoizedTypes.set(code, t);
 472         t->setCode(code);
 473         return t;
 474     }
 475 }
 476
 477
 478 /**
 479  * Code a table type as a tree in order to benefit of memoization
 480  */
 481
 482 static Tree  codeTableType(TableType* tt)
 483 {
 484     return tree(TABLETYPE, codeAudioType(tt->content()));
 485 }
 486
 487 AudioType* makeTableType(const Type& ct)
 488 {
 489     TableType   prototype(ct);
 490     Tree        code = codeAudioType(&prototype);
 491
 492     AudioType*  tt;
 493     if (MemoizedTypes.get(code, tt)) {
 494         return tt;
 495     } else {
 496         AudioType::gAllocationCount++;
 497         tt = new TableType(ct);
 498         MemoizedTypes.set(code, tt);
 499         tt->setCode(code);
 500         return tt;
 501     }
 502 }
 503
 504 AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec, int b, const interval& i)
 505 {
 506     TableType   prototype(ct,n,v,c,vec,b,i);
 507     Tree        code = codeAudioType(&prototype);
 508
 509     AudioType*  tt;
 510     if (MemoizedTypes.get(code, tt)) {
 511         return tt;
 512     } else {
 513         AudioType::gAllocationCount++;
 514         tt = new TableType(ct);
 515         MemoizedTypes.set(code, tt);
 516         tt->setCode(code);
 517         return tt;
 518     }
 519 }
 520
 521 AudioType* makeTableType(const Type& ct, int n, int v, int c, int vec)
 522 {
 523     TableType   prototype(ct,n,v,c,vec);
 524     Tree        code = codeAudioType(&prototype);
 525
 526     AudioType*  tt;
 527     if (MemoizedTypes.get(code, tt)) {
 528         return tt;
 529     } else {
 530         AudioType::gAllocationCount++;
 531         tt = new TableType(ct);
 532         MemoizedTypes.set(code, tt);
 533         tt->setCode(code);
 534         return tt;
 535     }
 536 }
 537
 538
 539 /**
 540  * Code a tuplet type as a tree in order to benefit of memoization
 541  */
 542
 543 static Tree codeTupletType(TupletType* nt)
 544 {
 545     vector<Tree> elems;
 546     for (int i=0; i<nt->arity(); i++) {
 547         elems.push_back(codeAudioType((*nt)[i]));
 548     }
 549     return CTree::make(TUPLETTYPE, elems);
 550 }
 551
 552 AudioType* makeTupletType(const vector<Type>& vt)
 553 {
 554     TupletType  prototype(vt);
 555     Tree        code = codeAudioType(&prototype);
 556
 557     AudioType*  t;
 558     if (MemoizedTypes.get(code, t)) {
 559         return t;
 560     } else {
 561         AudioType::gAllocationCount++;
 562         t = new TupletType(vt);
 563         MemoizedTypes.set(code, t);
 564         t->setCode(code);
 565         return t;
 566     }
 567
 568 }
 569
 570 AudioType* makeTupletType(const vector<Type>& vt, int n, int v, int c, int vec, int b, const interval& i)
 571 {
 572     TupletType  prototype(vt,n,v,c,vec,b,i);
 573     Tree        code = codeAudioType(&prototype);
 574
 575     AudioType*  t;
 576     if (MemoizedTypes.get(code, t)) {
 577         return t;
 578     } else {
 579         AudioType::gAllocationCount++;
 580         t = new TupletType(vt,n,v,c,vec,b,i);
 581         MemoizedTypes.set(code, t);
 582         t->setCode(code);
 583         return t;
 584     }
 585
 586 }
 587
 588 /**
 589  * Code a vector type as a tree in order to benefit of memoization
 590  */
 591
 592 static Tree codeVectorType(VectorType* vt)
 593 {
 594     assert(vt);
 595     //cerr << "codeVectorType(" << *vt << ")" << endl;
 596     int i = vt->size();
 597     return tree(VECTORTYPE, tree(i), codeAudioType(vt->content()));
 598 }
 599
 600 Type   makeVectorType(const Type& b, const vector<int>& dim)
 601 {
 602     Type r = b;
 603     for (unsigned   int i=0; i<dim.size(); i++) r = new VectorType(dim[i],r);
 604     return r;
 605 }
 606
 607
 608 /**
 609  * Returns true if D1 and D2 are compatible (one is the prefix of the other)).
 610  * In this case D3 contains the longuest vector D1 or D2
 611  */
 612 bool maxdimensions(const vector<int>& D1, const vector<int>& D2, vector<int>& D3)
 613 {
 614     unsigned int n1 = D1.size();
 615     unsigned int n2 = D2.size();
 616     unsigned int i = 0;
 617     while ( (i<n1) && (i<n2) && (D1[i]==D2[i]) ) i++;
 618     if (i==n1) {
 619         D3=D2;
 620         return true;
 621     } else if (i==n2) {
 622         D3=D1;
 623         return true;
 624     } else {
 625         return false;
 626     }
 627 }