interpreter/preprocessor/faust-0.9.47mr3/compiler/generator/compile_scal.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         HISTORY
  24         22/01/05 : corrected bug on bool signals cached in float variables
  25 *****************************************************************************/
  26
  27
  28 #include "compile_scal.hh"
  29 #include "timing.hh"
  30
  31 #include "compile.hh"
  32 #include "sigtype.hh"
  33
  34 #include <stdio.h>
  35 #include <iostream>
  36 #include <fstream>
  37 #include <sstream>
  38 #include <vector>
  39 #include <math.h>
  40
  41 #include "floats.hh"
  42 #include "sigprint.hh"
  43 #include "sigtyperules.hh"
  44 #include "recursivness.hh"
  45 #include "simplify.hh"
  46 #include "privatise.hh"
  47 #include "prim2.hh"
  48 #include "xtended.hh"
  49
  50 #include "compatibility.hh"
  51 #include "ppsig.hh"
  52 #include "sigToGraph.hh"
  53
  54 using namespace std;
  55
  56 extern bool     gDrawSignals;
  57 extern bool     gLessTempSwitch;
  58 extern int      gMaxCopyDelay;
  59 extern string   gClassName;
  60 extern string   gMasterDocument;
  61
  62 static Klass* signal2klass (const string& name, Tree sig)
  63 {
  64         Type t = getCertifiedSigType(sig); //, NULLENV);
  65         if (t->nature() == kInt) {
  66
  67                 ScalarCompiler C( new SigIntGenKlass(name) );
  68                 C.compileSingleSignal(sig);
  69                 return C.getClass();
  70
  71         } else {
  72
  73                 ScalarCompiler C( new SigFloatGenKlass(name) );
  74                 C.compileSingleSignal(sig);
  75                 return C.getClass();
  76
  77         }
  78 }
  79
  80
  81 /*****************************************************************************
  82                                                 getFreshID
  83 *****************************************************************************/
  84
  85 map<string, int>        ScalarCompiler::fIDCounters;
  86
  87 string ScalarCompiler::getFreshID(const string& prefix)
  88 {
  89         if (fIDCounters.find(prefix) == fIDCounters.end()) {
  90                 fIDCounters[prefix]=0;
  91         }
  92         int n = fIDCounters[prefix];
  93         fIDCounters[prefix] = n+1;
  94         return subst("$0$1", prefix, T(n));
  95 }
  96
  97
  98 /*****************************************************************************
  99                                                     prepare
 100 *****************************************************************************/
 101
 102 extern bool gDumpNorm;
 103
 104 Tree ScalarCompiler::prepare(Tree LS)
 105 {
 106 startTiming("ScalarCompiler::prepare");
 107  startTiming("deBruijn2Sym");
 108         Tree L1 = deBruijn2Sym(LS);     // convert debruijn recursion into symbolic recursion
 109  endTiming("deBruijn2Sym");
 110         Tree L2 = simplify(L1);                 // simplify by executing every computable operation
 111         Tree L3 = privatise(L2);                // Un-share tables with multiple writers
 112
 113         // dump normal form
 114         if (gDumpNorm) {
 115                 cout << ppsig(L3) << endl;
 116                 exit(0);
 117         }
 118
 119         recursivnessAnnotation(L3);             // Annotate L3 with recursivness information
 120
 121     startTiming("typeAnnotation");
 122         typeAnnotation(L3);                             // Annotate L3 with type information
 123     endTiming("typeAnnotation");
 124
 125     sharingAnalysis(L3);                        // annotate L3 with sharing count
 126         fOccMarkup.mark(L3);                    // annotate L3 with occurences analysis
 127     //annotationStatistics();
 128 endTiming("ScalarCompiler::prepare");
 129
 130     fRates = new RateInferrer(L3);
 131     if (gDrawSignals) {
 132         ofstream dotfile(subst("$0-sig.dot", gMasterDocument).c_str());
 133         sigToGraph(L3, dotfile, fRates);
 134     }
 135         return L3;
 136 }
 137
 138 Tree ScalarCompiler::prepare2(Tree L0)
 139 {
 140 startTiming("ScalarCompiler::prepare2");
 141         recursivnessAnnotation(L0);             // Annotate L0 with recursivness information
 142         typeAnnotation(L0);                             // Annotate L0 with type information
 143         sharingAnalysis(L0);                    // annotate L0 with sharing count
 144         fOccMarkup.mark(L0);                    // annotate L0 with occurences analysis
 145 endTiming("ScalarCompiler::prepare2");
 146
 147         return L0;
 148 }
 149
 150 /*****************************************************************************
 151                                                     compileMultiSignal
 152 *****************************************************************************/
 153
 154 void ScalarCompiler::compileMultiSignal (Tree L)
 155 {
 156         //contextor recursivness(0);
 157         L = prepare(L);         // optimize, share and annotate expression
 158
 159     for (int i = 0; i < fClass->inputs(); i++) {
 160         fClass->addZone3(subst("$1* input$0 = input[$0];", T(i), xfloat()));
 161     }
 162     for (int i = 0; i < fClass->outputs(); i++) {
 163         fClass->addZone3(subst("$1* output$0 = output[$0];", T(i), xfloat()));
 164     }
 165
 166         for (int i = 0; isList(L); L = tl(L), i++) {
 167                 Tree sig = hd(L);
 168                 fClass->addExecCode(subst("output$0[i] = $2$1;", T(i), CS(sig), xcast()));
 169         }
 170         generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
 171         generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
 172         if (fDescription) {
 173                 fDescription->ui(prepareUserInterfaceTree(fUIRoot));
 174         }
 175 }
 176
 177
 178 /*****************************************************************************
 179                                                     compileSingleSignal
 180 *****************************************************************************/
 181
 182 void ScalarCompiler::compileSingleSignal (Tree sig)
 183 {
 184         //contextor recursivness(0);
 185         sig = prepare2(sig);            // optimize and annotate expression
 186         fClass->addExecCode(subst("output[i] = $0;", CS(sig)));
 187         generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
 188         generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
 189         if (fDescription) {
 190                 fDescription->ui(prepareUserInterfaceTree(fUIRoot));
 191         }
 192 }
 193
 194
 195 /*****************************************************************************
 196                                                          CS : compile a signal
 197 *****************************************************************************/
 198
 199 /**
 200  * Test if a signal is already compiled
 201  * @param sig the signal expression to compile.
 202  * @param name the string representing the compiled expression.
 203  * @return true is already compiled
 204  */
 205 bool ScalarCompiler::getCompiledExpression(Tree sig, string& cexp)
 206 {
 207     return fCompileProperty.get(sig, cexp);
 208 }
 209
 210 /**
 211  * Set the string of a compiled expression is already compiled
 212  * @param sig the signal expression to compile.
 213  * @param cexp the string representing the compiled expression.
 214  * @return the cexp (for commodity)
 215  */
 216 string ScalarCompiler::setCompiledExpression(Tree sig, const string& cexp)
 217 {
 218     //cerr << "ScalarCompiler::setCompiledExpression : " << cexp << " ==> " << ppsig(sig) << endl;
 219     string old; if (fCompileProperty.get(sig, old) && (old != cexp)) {
 220         cerr << "ERROR already a compiled expression attached : " << old << " replaced by " << cexp << endl;
 221         exit(1);
 222     }
 223     fCompileProperty.set(sig, cexp);
 224         return cexp;
 225 }
 226
 227 /**
 228  * Compile a signal
 229  * @param sig the signal expression to compile.
 230  * @return the C code translation of sig as a string
 231  */
 232 string  ScalarCompiler::CS (Tree sig)
 233 {
 234     //contextor   contextRecursivness;
 235     string      code;
 236
 237     if (!getCompiledExpression(sig, code)) {
 238         // not compiled yet
 239 /*        if (getRecursivness(sig) != contextRecursivness.get()) {
 240             contextRecursivness.set(getRecursivness(sig));
 241         }*/
 242         code = generateCode(sig);
 243         setCompiledExpression(sig, code);
 244     }
 245     return code;
 246 }
 247
 248 /*****************************************************************************
 249                                                 generateCode : dispatch according to signal
 250 *****************************************************************************/
 251 /**
 252  * Main code generator dispatch.
 253  * @param sig the signal expression to compile.
 254  * @return the C code translation of sig
 255  */
 256
 257 string  ScalarCompiler::generateCode (Tree sig)
 258 {
 259 #if 0
 260         fprintf(stderr, "CALL generateCode(");
 261         printSignal(sig, stderr);
 262         fprintf(stderr, ")\n");
 263 #endif
 264
 265         int     i;
 266         double  r;
 267         Tree    c, sel, x, y, z, label, id, ff, largs, type, name, file;
 268
 269         //printf("compilation of %p : ", sig); print(sig); printf("\n");
 270
 271                  if ( getUserData(sig) )                                        { return generateXtended(sig); }
 272         else if ( isSigInt(sig, &i) )                                   { return generateNumber(sig, T(i)); }
 273         else if ( isSigReal(sig, &r) )                                  { return generateNumber(sig, T(r)); }
 274         else if ( isSigInput(sig, &i) )                                 { return generateInput  (sig, T(i));                    }
 275         else if ( isSigOutput(sig, &i, x) )                     { return generateOutput         (sig, T(i), CS(x));}
 276
 277         else if ( isSigFixDelay(sig, x, y) )                    { return generateFixDelay       (sig, x, y);                    }
 278         else if ( isSigPrefix(sig, x, y) )                              { return generatePrefix         (sig, x, y);                    }
 279         else if ( isSigIota(sig, x) )                                   { return generateIota           (sig, x);                               }
 280
 281         else if ( isSigBinOp(sig, &i, x, y) )                   { return generateBinOp  (sig, i, x, y);                 }
 282         else if ( isSigFFun(sig, ff, largs) )                   { return generateFFun           (sig, ff, largs);               }
 283     else if ( isSigFConst(sig, type, name, file) )  { return generateFConst(sig, tree2str(file), tree2str(name)); }
 284     else if ( isSigFVar(sig, type, name, file) )    { return generateFVar(sig, tree2str(file), tree2str(name)); }
 285
 286         else if ( isSigTable(sig, id, x, y) )                   { return generateTable  (sig, x, y);                    }
 287         else if ( isSigWRTbl(sig, id, x, y, z) )                { return generateWRTbl  (sig, x, y, z);                 }
 288         else if ( isSigRDTbl(sig, x, y) )                               { return generateRDTbl  (sig, x, y);                    }
 289
 290         else if ( isSigSelect2(sig, sel, x, y) )                { return generateSelect2        (sig, sel, x, y);               }
 291         else if ( isSigSelect3(sig, sel, x, y, z) )     { return generateSelect3        (sig, sel, x, y, z);    }
 292
 293         else if ( isSigGen(sig, x) )                                    { return generateSigGen         (sig, x);                               }
 294
 295     else if ( isProj(sig, &i, x) )                  { return generateRecProj    (sig, x, i);    }
 296
 297         else if ( isSigIntCast(sig, x) )                                { return generateIntCast   (sig, x);                            }
 298         else if ( isSigFloatCast(sig, x) )                              { return generateFloatCast (sig, x);                            }
 299
 300         else if ( isSigButton(sig, label) )                     { return generateButton         (sig, label);                   }
 301         else if ( isSigCheckbox(sig, label) )                   { return generateCheckbox       (sig, label);                   }
 302         else if ( isSigVSlider(sig, label,c,x,y,z) )    { return generateVSlider        (sig, label, c,x,y,z); }
 303         else if ( isSigHSlider(sig, label,c,x,y,z) )    { return generateHSlider        (sig, label, c,x,y,z); }
 304         else if ( isSigNumEntry(sig, label,c,x,y,z) )   { return generateNumEntry       (sig, label, c,x,y,z); }
 305
 306         else if ( isSigVBargraph(sig, label,x,y,z) )    { return generateVBargraph      (sig, label, x, y, CS(z)); }
 307         else if ( isSigHBargraph(sig, label,x,y,z) )    { return generateHBargraph      (sig, label, x, y, CS(z)); }
 308         else if ( isSigAttach(sig, x, y) )                              { CS(y); return generateCacheCode(sig, CS(x)); }
 309
 310     else if ( isSigUpSample(sig, x, y) )            { return generateUpSample(sig, x, y); }
 311     else if ( isSigDownSample(sig, x, y) )          { return generateDownSample(sig, x, y); }
 312
 313
 314         else {
 315                 printf("Error in compiling signal, unrecognized signal : ");
 316                 print(sig);
 317                 printf("\n");
 318                 exit(1);
 319         }
 320         return "error in generate code";
 321 }
 322
 323
 324 /*****************************************************************************
 325                                                            NUMBERS
 326 *****************************************************************************/
 327
 328
 329 string ScalarCompiler::generateNumber (Tree sig, const string& exp)
 330 {
 331         string          ctype, vname;
 332         Occurences* o = fOccMarkup.retrieve(sig);
 333
 334         // check for number occuring in delays
 335         if (o->getMaxDelay()>0) {
 336                 getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
 337                 generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
 338         }
 339         return exp;
 340 }
 341
 342 /*****************************************************************************
 343                                FOREIGN CONSTANTS
 344 *****************************************************************************/
 345
 346
 347 string ScalarCompiler::generateFConst (Tree sig, const string& file, const string& exp)
 348 {
 349     string      ctype, vname;
 350     Occurences* o = fOccMarkup.retrieve(sig);
 351
 352     addIncludeFile(file);
 353
 354     if (o->getMaxDelay()>0) {
 355         getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
 356         generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
 357     }
 358     return exp;
 359 }
 360
 361 /*****************************************************************************
 362                                FOREIGN VARIABLES
 363 *****************************************************************************/
 364
 365
 366 string ScalarCompiler::generateFVar (Tree sig, const string& file, const string& exp)
 367 {
 368     string      ctype, vname;
 369
 370     addIncludeFile(file);
 371     return generateCacheCode(sig, exp);
 372 }
 373
 374 /*****************************************************************************
 375                                                            INPUTS - OUTPUTS
 376 *****************************************************************************/
 377
 378
 379 string ScalarCompiler::generateInput (Tree sig, const string& idx)
 380 {
 381         return generateCacheCode(sig, subst("$1input$0[i]", idx, icast()));
 382 }
 383
 384
 385 string ScalarCompiler::generateOutput (Tree sig, const string& idx, const string& arg)
 386 {
 387         string dst = subst("output$0[i]", idx);
 388         fClass->addExecCode(subst("$0 = $2$1;", dst, arg, xcast()));
 389         return dst;
 390 }
 391
 392
 393 /*****************************************************************************
 394                                                            BINARY OPERATION
 395 *****************************************************************************/
 396
 397 string ScalarCompiler::generateBinOp(Tree sig, int opcode, Tree arg1, Tree arg2)
 398 {
 399         return generateCacheCode(sig, subst("($0 $1 $2)", CS(arg1), gBinOpTable[opcode]->fName, CS(arg2)));
 400 }
 401
 402
 403 /*****************************************************************************
 404                                                            Primitive Operations
 405 *****************************************************************************/
 406
 407 string ScalarCompiler::generateFFun(Tree sig, Tree ff, Tree largs)
 408 {
 409         addIncludeFile(ffincfile(ff));  //printf("inc file %s\n", ffincfile(ff));
 410         addLibrary(fflibfile(ff));              //printf("lib file %s\n", fflibfile(ff));
 411
 412     string code = ffname(ff);
 413     code += '(';
 414     string sep = "";
 415     for (int i = 0; i< ffarity(ff); i++) {
 416         code += sep;
 417         code += CS(nth(largs, i));
 418         sep = ", ";
 419     }
 420     code += ')';
 421     return generateCacheCode(sig, code);
 422 }
 423
 424
 425 /*****************************************************************************
 426                                                            CACHE CODE
 427 *****************************************************************************/
 428
 429 void ScalarCompiler::getTypedNames(Type t, const string& prefix, string& ctype, string& vname)
 430 {
 431     if (t->nature() == kInt) {
 432         ctype = "int"; vname = subst("i$0", getFreshID(prefix));
 433     } else {
 434         ctype = ifloat(); vname = subst("f$0", getFreshID(prefix));
 435     }
 436 }
 437
 438 string ScalarCompiler::generateCacheCode(Tree sig, const string& exp)
 439 {
 440         string          vname, ctype, code;
 441         int             sharing = getSharingCount(sig);
 442         Occurences* o = fOccMarkup.retrieve(sig);
 443
 444         // check reentrance
 445     if (getCompiledExpression(sig, code)) {
 446         return code;
 447     }
 448
 449         // check for expression occuring in delays
 450         if (o->getMaxDelay()>0) {
 451
 452         getTypedNames(getCertifiedSigType(sig), "Vec", ctype, vname);
 453         if (sharing>1) {
 454             return generateDelayVec(sig, generateVariableStore(sig,exp), ctype, vname, o->getMaxDelay());
 455         } else {
 456                     return generateDelayVec(sig, exp, ctype, vname, o->getMaxDelay());
 457         }
 458
 459         } else if (sharing == 1) {
 460
 461         return exp;
 462
 463         } else if (sharing > 1) {
 464
 465         return generateVariableStore(sig, exp);
 466
 467         } else {
 468         cerr << "Error in sharing count (" << sharing << ") for " << *sig << endl;
 469                 exit(1);
 470         }
 471
 472         return "Error in generateCacheCode";
 473 }
 474
 475
 476 string ScalarCompiler::generateVariableStore(Tree sig, const string& exp)
 477 {
 478     string      vname, ctype;
 479     Type        t = getCertifiedSigType(sig);
 480
 481     switch (t->variability()) {
 482
 483         case kKonst :
 484
 485             getTypedNames(t, "Const", ctype, vname);
 486             fClass->addDeclCode(subst("$0 \t$1;", ctype, vname));
 487             fClass->addInitCode(subst("$0 = $1;", vname, exp));
 488             break;
 489
 490         case kBlock :
 491
 492             getTypedNames(t, "Slow", ctype, vname);
 493             fClass->addFirstPrivateDecl(vname);
 494             fClass->addZone2(subst("$0 \t$1 = $2;", ctype, vname, exp));
 495             break;
 496
 497         case kSamp :
 498
 499             getTypedNames(t, "Temp", ctype, vname);
 500             fClass->addExecCode(subst("$0 $1 = $2;", ctype, vname, exp));
 501             break;
 502     }
 503     return vname;
 504 }
 505
 506
 507 /*****************************************************************************
 508                                                                     CASTING
 509 *****************************************************************************/
 510
 511
 512 string ScalarCompiler::generateIntCast(Tree sig, Tree x)
 513 {
 514         return generateCacheCode(sig, subst("int($0)", CS(x)));
 515 }
 516
 517 string ScalarCompiler::generateFloatCast (Tree sig, Tree x)
 518 {
 519         return generateCacheCode(sig, subst("$1($0)", CS(x), ifloat()));
 520 }
 521
 522 /*****************************************************************************
 523                                                         user interface elements
 524 *****************************************************************************/
 525
 526 string ScalarCompiler::generateButton(Tree sig, Tree path)
 527 {
 528         string varname = getFreshID("fbutton");
 529         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 530         fClass->addInitCode(subst("$0 = 0.0;", varname));
 531         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 532         return generateCacheCode(sig, varname);
 533 }
 534
 535 string ScalarCompiler::generateCheckbox(Tree sig, Tree path)
 536 {
 537         string varname = getFreshID("fcheckbox");
 538         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 539         fClass->addInitCode(subst("$0 = 0.0;", varname));
 540         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 541         return generateCacheCode(sig, varname);
 542 }
 543
 544
 545 string ScalarCompiler::generateVSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
 546 {
 547         string varname = getFreshID("fslider");
 548         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 549         fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
 550         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 551         return generateCacheCode(sig, varname);
 552 }
 553
 554 string ScalarCompiler::generateHSlider(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
 555 {
 556         string varname = getFreshID("fslider");
 557         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 558         fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
 559         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 560         return generateCacheCode(sig, varname);
 561 }
 562
 563 string ScalarCompiler::generateNumEntry(Tree sig, Tree path, Tree cur, Tree min, Tree max, Tree step)
 564 {
 565         string varname = getFreshID("fentry");
 566         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 567         fClass->addInitCode(subst("$0 = $1;", varname, T(tree2float(cur))));
 568         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 569         return generateCacheCode(sig, varname);
 570 }
 571
 572
 573 string ScalarCompiler::generateVBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
 574 {
 575         string varname = getFreshID("fbargraph");
 576         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 577         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 578
 579         Type t = getCertifiedSigType(sig);
 580         switch (t->variability()) {
 581
 582                 case kKonst :
 583                         fClass->addInitCode(subst("$0 = $1;", varname, exp));
 584                         break;
 585
 586                 case kBlock :
 587                         fClass->addZone2(subst("$0 = $1;", varname, exp));
 588                         break;
 589
 590                 case kSamp :
 591                         fClass->addExecCode(subst("$0 = $1;", varname, exp));
 592                         break;
 593         }
 594
 595         //return varname;
 596     return generateCacheCode(sig, varname);
 597 }
 598
 599
 600 string ScalarCompiler::generateHBargraph(Tree sig, Tree path, Tree min, Tree max, const string& exp)
 601 {
 602         string varname = getFreshID("fbargraph");
 603         fClass->addDeclCode(subst("$1 \t$0;", varname, xfloat()));
 604         addUIWidget(reverse(tl(path)), uiWidget(hd(path), tree(varname), sig));
 605
 606         Type t = getCertifiedSigType(sig);
 607         switch (t->variability()) {
 608
 609                 case kKonst :
 610                         fClass->addInitCode(subst("$0 = $1;", varname, exp));
 611                         break;
 612
 613                 case kBlock :
 614                         fClass->addZone2(subst("$0 = $1;", varname, exp));
 615                         break;
 616
 617                 case kSamp :
 618                         fClass->addExecCode(subst("$0 = $1;", varname, exp));
 619                         break;
 620         }
 621
 622     //return varname;
 623     return generateCacheCode(sig, varname);
 624 }
 625
 626
 627
 628
 629 /*****************************************************************************
 630                                                                     TABLES
 631 *****************************************************************************/
 632
 633
 634
 635 /*----------------------------------------------------------------------------
 636                                                 sigGen : initial table content
 637 ----------------------------------------------------------------------------*/
 638
 639 string ScalarCompiler::generateSigGen(Tree sig, Tree content)
 640 {
 641         string klassname = getFreshID("SIG");
 642         string signame = getFreshID("sig");
 643
 644         fClass->addSubKlass(signal2klass(klassname, content));
 645         fClass->addInitCode(subst("$0 $1;", klassname, signame));
 646     fInstanceInitProperty.set(content, pair<string,string>(klassname,signame));
 647
 648         return signame;
 649 }
 650
 651 string ScalarCompiler::generateStaticSigGen(Tree sig, Tree content)
 652 {
 653         string klassname = getFreshID("SIG");
 654         string signame = getFreshID("sig");
 655
 656         fClass->addSubKlass(signal2klass(klassname, content));
 657         fClass->addStaticInitCode(subst("$0 $1;", klassname, signame));
 658     fStaticInitProperty.set(content, pair<string,string>(klassname,signame));
 659
 660         return signame;
 661 }
 662
 663
 664 /*----------------------------------------------------------------------------
 665                                                 sigTable : table declaration
 666 ----------------------------------------------------------------------------*/
 667
 668 string ScalarCompiler::generateTable(Tree sig, Tree tsize, Tree content)
 669 {
 670         string          generator(CS(content));
 671     Tree                g;
 672     string              cexp;
 673     string              ctype, vname;
 674         int             size;
 675
 676     // already compiled but check if we need to add declarations
 677
 678     assert ( isSigGen(content, g) );
 679     pair<string,string> kvnames;
 680     if ( ! fInstanceInitProperty.get(g, kvnames)) {
 681         // not declared here, we add a declaration
 682         bool b = fStaticInitProperty.get(g, kvnames);
 683         assert(b);
 684         fClass->addInitCode(subst("$0 $1;", kvnames.first, kvnames.second));
 685     }
 686
 687         if (!isSigInt(tsize, &size)) {
 688                 //fprintf(stderr, "error in ScalarCompiler::generateTable()\n"); exit(1);
 689                 cerr << "error in ScalarCompiler::generateTable() : "
 690                          << *tsize
 691              << " is not a constant integer table size expression "
 692                          << endl;
 693         exit(1);
 694         }
 695         // definition du nom et du type de la table
 696         // A REVOIR !!!!!!!!!
 697         Type t = getCertifiedSigType(content);//, tEnv);
 698         if (t->nature() == kInt) {
 699                 vname = getFreshID("itbl");
 700                 ctype = "int";
 701         } else {
 702                 vname = getFreshID("ftbl");
 703                 ctype = ifloat();
 704         }
 705
 706         // declaration de la table
 707         fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(size)));
 708
 709         // initialisation du generateur de contenu
 710         fClass->addInitCode(subst("$0.init(samplingFreq);", generator));
 711         // remplissage de la table
 712         fClass->addInitCode(subst("$0.fill($1,$2);", generator, T(size), vname));
 713
 714         // on retourne le nom de la table
 715         return vname;
 716 }
 717
 718 string ScalarCompiler::generateStaticTable(Tree sig, Tree tsize, Tree content)
 719 {
 720         //string                generator(CS(content));
 721         Tree            g;
 722         string          cexp;
 723         string          ctype, vname;
 724         int             size;
 725
 726         assert ( isSigGen(content, g) );
 727
 728         if (!getCompiledExpression(content, cexp)) {
 729                 cexp = setCompiledExpression(content, generateStaticSigGen(content, g));
 730     } else {
 731         // already compiled but check if we need to add declarations
 732         pair<string,string> kvnames;
 733         if ( ! fStaticInitProperty.get(g, kvnames)) {
 734             // not declared here, we add a declaration
 735             bool b = fInstanceInitProperty.get(g, kvnames);
 736             assert(b);
 737             fClass->addStaticInitCode(subst("$0 $1;", kvnames.first, kvnames.second));
 738         }
 739     }
 740
 741     if (!isSigInt(tsize, &size)) {
 742                 //fprintf(stderr, "error in ScalarCompiler::generateTable()\n"); exit(1);
 743                 cerr << "error in ScalarCompiler::generateTable() : "
 744                          << *tsize
 745              << " is not a constant integer table size expression "
 746                          << endl;
 747         exit(1);
 748         }
 749         // definition du nom et du type de la table
 750         // A REVOIR !!!!!!!!!
 751         Type t = getCertifiedSigType(content);//, tEnv);
 752         if (t->nature() == kInt) {
 753                 vname = getFreshID("itbl");
 754                 ctype = "int";
 755         } else {
 756                 vname = getFreshID("ftbl");
 757                 ctype = ifloat();
 758         }
 759
 760         // declaration de la table
 761         fClass->addDeclCode(subst("static $0 \t$1[$2];", ctype, vname, T(size)));
 762     fClass->addStaticFields(subst("$0 \t$1::$2[$3];", ctype, fClass->getClassName(), vname, T(size) ));
 763
 764         // initialisation du generateur de contenu
 765         fClass->addStaticInitCode(subst("$0.init(samplingFreq);", cexp));
 766         // remplissage de la table
 767         fClass->addStaticInitCode(subst("$0.fill($1,$2);", cexp, T(size), vname));
 768
 769         // on retourne le nom de la table
 770         return vname;
 771 }
 772
 773
 774 /*----------------------------------------------------------------------------
 775                                                 sigWRTable : table assignement
 776 ----------------------------------------------------------------------------*/
 777
 778 string ScalarCompiler::generateWRTbl(Tree sig, Tree tbl, Tree idx, Tree data)
 779 {
 780         string tblName(CS(tbl));
 781         fClass->addExecCode(subst("$0[$1] = $2;", tblName, CS(idx), CS(data)));
 782         return tblName;
 783 }
 784
 785
 786 /*----------------------------------------------------------------------------
 787                                                 sigRDTable : table access
 788 ----------------------------------------------------------------------------*/
 789
 790 string ScalarCompiler::generateRDTbl(Tree sig, Tree tbl, Tree idx)
 791 {
 792         // YO le 21/04/05 : La lecture des tables n'�ait pas mise dans le cache
 793         // et donc le code �ait dupliqu�(dans tester.dsp par exemple)
 794         //return subst("$0[$1]", CS(tEnv, tbl), CS(tEnv, idx));
 795
 796         //cerr << "generateRDTable " << *sig << endl;
 797         // test the special case of a read only table that can be compiled
 798         // has a static member
 799         Tree    id, size, content;
 800         if(     isSigTable(tbl, id, size, content) ) {
 801                 string tblname;
 802                 if (!getCompiledExpression(tbl, tblname)) {
 803                         tblname = setCompiledExpression(tbl, generateStaticTable(tbl, size, content));
 804                 }
 805                 return generateCacheCode(sig, subst("$0[$1]", tblname, CS(idx)));
 806         } else {
 807                 return generateCacheCode(sig, subst("$0[$1]", CS(tbl), CS(idx)));
 808         }
 809 }
 810
 811
 812
 813 /*****************************************************************************
 814                                                            RECURSIONS
 815 *****************************************************************************/
 816
 817
 818 /**
 819  * Generate code for a projection of a group of mutually recursive definitions
 820  */
 821 string ScalarCompiler::generateRecProj(Tree sig, Tree r, int i)
 822 {
 823     string  vname;
 824     Tree    var, le;
 825
 826     if ( ! getVectorNameProperty(sig, vname)) {
 827         assert(isRec(r, var, le));
 828         generateRec(r, var, le);
 829         assert(getVectorNameProperty(sig, vname));
 830     }
 831     return "[[UNUSED EXP]]";    // make sure the resulting expression is never used in the generated code
 832 }
 833
 834
 835 /**
 836  * Generate code for a group of mutually recursive definitions
 837  */
 838 void ScalarCompiler::generateRec(Tree sig, Tree var, Tree le)
 839 {
 840     int             N = len(le);
 841
 842     vector<bool>    used(N);
 843     vector<int>     delay(N);
 844     vector<string>  vname(N);
 845     vector<string>  ctype(N);
 846
 847     // prepare each element of a recursive definition
 848     for (int i=0; i<N; i++) {
 849         Tree    e = sigProj(i,sig);     // recreate each recursive definition
 850         if (fOccMarkup.retrieve(e)) {
 851             // this projection is used
 852             used[i] = true;
 853             getTypedNames(getCertifiedSigType(e), "Rec", ctype[i],  vname[i]);
 854             setVectorNameProperty(e, vname[i]);
 855             delay[i] = fOccMarkup.retrieve(e)->getMaxDelay();
 856         } else {
 857             // this projection is not used therefore
 858             // we should not generate code for it
 859             used[i] = false;
 860         }
 861     }
 862
 863     // generate delayline for each element of a recursive definition
 864     for (int i=0; i<N; i++) {
 865         if (used[i]) {
 866             generateDelayLine(ctype[i], vname[i], delay[i], CS(nth(le,i)));
 867         }
 868     }
 869 }
 870
 871
 872 /*****************************************************************************
 873                                                            PREFIX, DELAY A PREFIX VALUE
 874 *****************************************************************************/
 875
 876 string ScalarCompiler::generatePrefix (Tree sig, Tree x, Tree e)
 877 {
 878         Type te = getCertifiedSigType(sig);//, tEnv);
 879
 880         string vperm = getFreshID("M");
 881         string vtemp = getFreshID("T");
 882
 883         string type = cType(te);
 884
 885         fClass->addDeclCode(subst("$0 \t$1;", type, vperm));
 886         fClass->addInitCode(subst("$0 = $1;", vperm, CS(x)));
 887
 888         fClass->addExecCode(subst("$0 $1 = $2;", type, vtemp, vperm));
 889         fClass->addExecCode(subst("$0 = $1;", vperm, CS(e)));
 890         return vtemp;
 891 }
 892
 893
 894 /*****************************************************************************
 895                                                            IOTA(n)
 896 *****************************************************************************/
 897 static bool isPowerOf2(int n)
 898 {
 899         return !(n & (n - 1));
 900 }
 901
 902 string ScalarCompiler::generateIota (Tree sig, Tree n)
 903 {
 904         int size;
 905         if (!isSigInt(n, &size)) { fprintf(stderr, "error in generateIota\n"); exit(1); }
 906
 907         string vperm = getFreshID("iota");
 908
 909         fClass->addDeclCode(subst("int \t$0;",  vperm));
 910         fClass->addInitCode(subst("$0 = 0;", vperm));
 911
 912         if (isPowerOf2(size)) {
 913                 fClass->addExecCode(subst("$0 = ($0+1)&$1;", vperm, T(size-1)));
 914         } else {
 915                 fClass->addExecCode(subst("if (++$0 == $1) $0=0;", vperm, T(size)));
 916         }
 917         return vperm;
 918 }
 919
 920
 921
 922 // a revoir en utilisant la lecture de table et en partageant la construction de la paire de valeurs
 923
 924
 925 /**
 926  * Generate a select2 code
 927  */
 928
 929 string ScalarCompiler::generateSelect2  (Tree sig, Tree sel, Tree s1, Tree s2)
 930 {
 931     return generateCacheCode(sig, subst( "(($0)?$1:$2)", CS(sel), CS(s2), CS(s1) ) );
 932 }
 933
 934
 935 /**
 936  * Generate a select3 code (using if-then-else)
 937  * ((int n = sel==0)? s0 : ((sel==1)? s1 : s2))
 938  * int nn; ((nn=sel) ? ((nn==1)? s1 : s2) : s0);
 939  */
 940 string ScalarCompiler::generateSelect3  (Tree sig, Tree sel, Tree s1, Tree s2, Tree s3)
 941 {
 942     return generateCacheCode(sig, subst( "(($0==0)? $1 : (($0==1)?$2:$3) )", CS(sel), CS(s1), CS(s2), CS(s3) ) );
 943 }
 944
 945 #if 0
 946 string ScalarCompiler::generateSelect3  (Tree sig, Tree sel, Tree s1, Tree s2, Tree s3)
 947 {
 948     Type t  = getCertifiedSigType(sig);
 949     Type t1 = getCertifiedSigType(s1);
 950     Type t2 = getCertifiedSigType(s2);
 951     Type t3 = getCertifiedSigType(s3);
 952     Type w  = min(t1,min(t2,t3));
 953
 954     string type = cType(t);
 955     string var  = getFreshID("S");
 956
 957     switch (w->variability())
 958     {
 959         case kKonst :
 960             fClass->addDeclCode(subst("$0 \t$1[3];", type, var));
 961             break;
 962         case kBlock :
 963             //fClass->addLocalDecl(type, subst("$0[3]", var));
 964             //fClass->addLocalVecDecl(type, var, 3);
 965             fClass->addSharedDecl(var);
 966             fClass->addZone1(subst("$0 \t$1[3];", type, var));
 967             break;
 968         case kSamp :
 969             fClass->addExecCode(subst("$0 \t$1[3];", type, var));
 970             break;
 971     }
 972
 973     switch (t1->variability())
 974     {
 975         case kKonst :
 976             fClass->addInitCode(subst("$0[0] = $1;", var, CS(s1)));
 977             break;
 978         case kBlock :
 979             fClass->addZone2b(subst("$0[0] = $1;", var, CS(s1)));
 980             break;
 981         case kSamp :
 982             fClass->addExecCode(subst("$0[0] = $1;", var, CS(s1)));
 983             break;
 984     }
 985
 986     switch (t2->variability())
 987     {
 988         case kKonst :
 989             fClass->addInitCode(subst("$0[1] = $1;", var, CS(s2)));
 990             break;
 991         case kBlock :
 992             fClass->addZone2b(subst("$0[1] = $1;", var, CS(s2)));
 993             break;
 994         case kSamp :
 995             fClass->addExecCode(subst("$0[1] = $1;", var, CS(s2)));
 996             break;
 997     }
 998
 999     switch (t3->variability())
1000     {
1001         case kKonst :
1002             fClass->addInitCode(subst("$0[2] = $1;", var, CS(s3)));
1003             break;
1004         case kBlock :
1005             fClass->addZone2b(subst("$0[2] = $1;", var, CS(s3)));
1006             break;
1007         case kSamp :
1008             fClass->addExecCode(subst("$0[2] = $1;", var, CS(s3)));
1009             break;
1010     }
1011
1012     return generateCacheCode(sig, subst("$0[$1]", var, CS(sel)));
1013 }
1014 #endif
1015
1016 /**
1017  * retrieve the type annotation of sig
1018  * @param sig the signal we want to know the type
1019  */
1020 string ScalarCompiler::generateXtended  (Tree sig)
1021 {
1022         xtended*                p = (xtended*) getUserData(sig);
1023         vector<string>  args;
1024         vector<Type>    types;
1025
1026         for (int i=0; i<sig->arity(); i++) {
1027                 args.push_back(CS(sig->branch(i)));
1028                 types.push_back(getCertifiedSigType(sig->branch(i)));
1029         }
1030
1031         if (p->needCache()) {
1032                 return generateCacheCode(sig, p->generateCode(fClass, args, types));
1033         } else {
1034                 return p->generateCode(fClass, args, types);
1035         }
1036 }
1037
1038
1039
1040 //------------------------------------------------------------------------------------------------
1041
1042
1043 /*****************************************************************************
1044                                                 vector name property
1045 *****************************************************************************/
1046
1047 /**
1048  * Set the vector name property of a signal, the name of the vector used to
1049  * store the previous values of the signal to implement a delay.
1050  * @param sig the signal expression.
1051  * @param vecname the string representing the vector name.
1052  * @return true is already compiled
1053  */
1054 void ScalarCompiler::setVectorNameProperty(Tree sig, const string& vecname)
1055 {
1056         fVectorProperty.set(sig, vecname);
1057 }
1058
1059
1060 /**
1061  * Get the vector name property of a signal, the name of the vector used to
1062  * store the previous values of the signal to implement a delay.
1063  * @param sig the signal expression.
1064  * @param vecname the string where to store the vector name.
1065  * @return true if the signal has this property, false otherwise
1066  */
1067
1068 bool ScalarCompiler::getVectorNameProperty(Tree sig, string& vecname)
1069 {
1070     return fVectorProperty.get(sig, vecname);
1071 }
1072
1073
1074 /**
1075  * Compute the minimal power of 2 greater than x
1076  */
1077
1078 int ScalarCompiler::pow2limit(int x)
1079 {
1080         int n = 2;
1081         while (n < x) { n = 2*n; }
1082         return n;
1083 }
1084
1085 /*****************************************************************************
1086                                                            N-SAMPLE FIXED DELAY : sig = exp@delay
1087
1088         case 1-sample max delay :
1089                 Y(t-0)  Y(t-1)
1090                 Temp    Var                                             gLessTempSwitch = false
1091                 V[0]    V[1]                                    gLessTempSwitch = true
1092
1093         case max delay < gMaxCopyDelay :
1094                 Y(t-0)  Y(t-1)  Y(t-2)  ...
1095                 Temp    V[0]    V[1]    ...             gLessTempSwitch = false
1096                 V[0]    V[1]    V[2]    ...             gLessTempSwitch = true
1097
1098         case max delay >= gMaxCopyDelay :
1099                 Y(t-0)  Y(t-1)  Y(t-2)  ...
1100                 Temp    V[0]    V[1]    ...
1101                 V[0]    V[1]    V[2]    ...
1102
1103
1104 *****************************************************************************/
1105
1106 /**
1107  * Generate code for accessing a delayed signal. The generated code depend of
1108  * the maximum delay attached to exp and the gLessTempSwitch.
1109  */
1110
1111 string ScalarCompiler::generateFixDelay (Tree sig, Tree exp, Tree delay)
1112 {
1113         int     mxd, d;
1114         string  vecname;
1115
1116     //cerr << "ScalarCompiler::generateFixDelay sig = " << *sig << endl;
1117     //cerr << "ScalarCompiler::generateFixDelay exp = " << *exp << endl;
1118     //cerr << "ScalarCompiler::generateFixDelay del = " << *delay << endl;
1119
1120     CS(exp); // ensure exp is compiled to have a vector name
1121
1122         mxd = fOccMarkup.retrieve(exp)->getMaxDelay();
1123
1124         if (! getVectorNameProperty(exp, vecname)) {
1125         cerr << "No vector name for : " << ppsig(exp) << endl;
1126         assert(0);
1127     }
1128
1129     if (mxd == 0) {
1130         // not a real vector name but a scalar name
1131         return vecname;
1132
1133         } else if (mxd < gMaxCopyDelay) {
1134                 if (isSigInt(delay, &d)) {
1135                         return subst("$0[$1]", vecname, CS(delay));
1136                 } else {
1137                         return generateCacheCode(sig, subst("$0[$1]", vecname, CS(delay)));
1138                 }
1139
1140         } else {
1141
1142                 // long delay : we use a ring buffer of size 2^x
1143                 int     N       = pow2limit( mxd+1 );
1144                 return generateCacheCode(sig, subst("$0[(IOTA-$1)&$2]", vecname, CS(delay), T(N-1)));
1145         }
1146 }
1147
1148
1149 /**
1150  * Generate code for the delay mecchanism. The generated code depend of the
1151  * maximum delay attached to exp and the "less temporaries" switch
1152  */
1153
1154 string ScalarCompiler::generateDelayVec(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
1155 {
1156         string s = generateDelayVecNoTemp(sig, exp, ctype, vname, mxd);
1157         if (getCertifiedSigType(sig)->variability() < kSamp) {
1158         return exp;
1159         } else {
1160                 return s;
1161         }
1162 }
1163
1164 /**
1165  * Generate code for the delay mecchanism without using temporary variables
1166  */
1167
1168 string ScalarCompiler::generateDelayVecNoTemp(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
1169 {
1170     assert(mxd > 0);
1171
1172     //bool odocc = fOccMarkup.retrieve(sig)->hasOutDelayOccurences();
1173
1174     if (mxd < gMaxCopyDelay) {
1175
1176         // short delay : we copy
1177         fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(mxd+1)));
1178         fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(mxd+1)));
1179         fClass->addExecCode(subst("$0[0] = $1;", vname, exp));
1180
1181         // generate post processing copy code to update delay values
1182         if (mxd == 1) {
1183             fClass->addPostCode(subst("$0[1] = $0[0];", vname));
1184         } else if (mxd == 2) {
1185             //fClass->addPostCode(subst("$0[2] = $0[1];", vname));
1186             fClass->addPostCode(subst("$0[2] = $0[1]; $0[1] = $0[0];", vname));
1187         } else {
1188             fClass->addPostCode(subst("for (int i=$0; i>0; i--) $1[i] = $1[i-1];", T(mxd), vname));
1189         }
1190         setVectorNameProperty(sig, vname);
1191         return subst("$0[0]", vname);
1192
1193     } else {
1194
1195         // generate code for a long delay : we use a ring buffer of size N = 2**x > mxd
1196         int     N = pow2limit(mxd+1);
1197
1198         // we need a iota index
1199         ensureIotaCode();
1200
1201         // declare and init
1202         fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(N)));
1203         fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(N)));
1204
1205         // execute
1206         fClass->addExecCode(subst("$0[IOTA&$1] = $2;", vname, T(N-1), exp));
1207         setVectorNameProperty(sig, vname);
1208         return subst("$0[IOTA&$1]", vname, T(N-1));
1209     }
1210 }
1211
1212 /**
1213  * Generate code for the delay mecchanism without using temporary variables
1214  */
1215
1216 void ScalarCompiler::generateDelayLine(const string& ctype, const string& vname, int mxd, const string& exp)
1217 {
1218     //assert(mxd > 0);
1219     if (mxd == 0) {
1220         // cerr << "MXD==0 :  " << vname << " := " << exp << endl;
1221         // no need for a real vector
1222         fClass->addExecCode(subst("$0 \t$1 = $2;", ctype, vname, exp));
1223
1224
1225     } else if (mxd < gMaxCopyDelay) {
1226         // cerr << "small delay : " << vname << "[" << mxd << "]" << endl;
1227
1228         // short delay : we copy
1229         fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(mxd+1)));
1230         fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(mxd+1)));
1231         fClass->addExecCode(subst("$0[0] = $1;", vname, exp));
1232
1233         // generate post processing copy code to update delay values
1234         if (mxd == 1) {
1235             fClass->addPostCode(subst("$0[1] = $0[0];", vname));
1236         } else if (mxd == 2) {
1237             fClass->addPostCode(subst("$0[2] = $0[1]; $0[1] = $0[0];", vname));
1238         } else {
1239             fClass->addPostCode(subst("for (int i=$0; i>0; i--) $1[i] = $1[i-1];", T(mxd), vname));
1240         }
1241
1242     } else {
1243
1244         // generate code for a long delay : we use a ring buffer of size N = 2**x > mxd
1245         int     N = pow2limit(mxd+1);
1246
1247         // we need a iota index
1248         ensureIotaCode();
1249
1250         // declare and init
1251         fClass->addDeclCode(subst("$0 \t$1[$2];", ctype, vname, T(N)));
1252         fClass->addInitCode(subst("for (int i=0; i<$1; i++) $0[i] = 0;", vname, T(N)));
1253
1254         // execute
1255         fClass->addExecCode(subst("$0[IOTA&$1] = $2;", vname, T(N-1), exp));
1256     }
1257 }
1258
1259 /**
1260  * Generate up sampling code
1261  */
1262
1263 string ScalarCompiler::generateUpSample(Tree sig, Tree w, Tree x)
1264 {
1265     return CS(x);
1266 }
1267
1268 /**
1269  * Generate down sampling code
1270  */
1271
1272 string ScalarCompiler::generateDownSample(Tree sig, Tree w, Tree x)
1273 {
1274     return CS(x);
1275 }
1276
1277
1278 /**
1279  * Generate code for a unique IOTA variable increased at each sample
1280  * and used to index ring buffers.
1281  */
1282 void ScalarCompiler::ensureIotaCode()
1283 {
1284         if (!fHasIota) {
1285                 fHasIota = true;
1286                 fClass->addDeclCode("int \tIOTA;");
1287                 fClass->addInitCode("IOTA = 0;");
1288                 fClass->addPostCode("IOTA = IOTA+1;");
1289         }
1290 }