/[svn]/linuxsampler/trunk/src/scriptvm/tree.cpp
ViewVC logotype

Diff of /linuxsampler/trunk/src/scriptvm/tree.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 2581 by schoenebeck, Fri May 30 12:48:05 2014 UTC revision 2945 by schoenebeck, Thu Jul 14 00:22:26 2016 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 Christian Schoenebeck and Andreas Persson   * Copyright (c) 2014 - 2016 Christian Schoenebeck and Andreas Persson
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 11  Line 11 
11  #include <string.h>  #include <string.h>
12  #include "tree.h"  #include "tree.h"
13  #include "../common/global_private.h"  #include "../common/global_private.h"
14    #include <assert.h>
15    
16  namespace LinuxSampler {  namespace LinuxSampler {
17            
# Line 101  void Mul::dump(int level) { Line 102  void Mul::dump(int level) {
102    
103  int Div::evalInt() {  int Div::evalInt() {
104      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
105      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
106      return (pLHS && pRHS) ? pRHS->evalInt() == 0 ? 0 : pLHS->evalInt() / pRHS->evalInt() : 0;      if (!pLHS || !pRHS) return 0;
107        int l = pLHS->evalInt();
108        int r = pRHS->evalInt();
109        if (r == 0) return 0;
110        return l / r;
111  }  }
112    
113  void Div::dump(int level) {  void Div::dump(int level) {
# Line 143  void Args::dump(int level) { Line 148  void Args::dump(int level) {
148      printf(")\n");      printf(")\n");
149  }  }
150    
151    bool Args::isPolyphonic() const {
152        for (int i = 0; i < args.size(); ++i)
153            if (args[i]->isPolyphonic())
154                return true;
155        return false;
156    }
157    
158  EventHandlers::EventHandlers() {  EventHandlers::EventHandlers() {
159      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
160  }  }
# Line 176  EventHandler* EventHandlers::eventHandle Line 188  EventHandler* EventHandlers::eventHandle
188      return const_cast<EventHandler*>(&*args.at(index));      return const_cast<EventHandler*>(&*args.at(index));
189  }  }
190    
191    bool EventHandlers::isPolyphonic() const {
192        for (int i = 0; i < args.size(); ++i)
193            if (args[i]->isPolyphonic())
194                return true;
195        return false;
196    }
197    
198  Assignment::Assignment(VariableRef variable, ExpressionRef value)  Assignment::Assignment(VariableRef variable, ExpressionRef value)
199     : variable(variable), value(value)     : variable(variable), value(value)
200  {  {
# Line 193  StmtFlags_t Assignment::exec() { Line 212  StmtFlags_t Assignment::exec() {
212      return STMT_SUCCESS;      return STMT_SUCCESS;
213  }  }
214    
215    EventHandler::EventHandler(StatementsRef statements) {
216        this->statements = statements;
217        usingPolyphonics = statements->isPolyphonic();
218    }
219    
220  void EventHandler::dump(int level) {  void EventHandler::dump(int level) {
221      printIndents(level);      printIndents(level);
222      printf("EventHandler {\n");      printf("EventHandler {\n");
# Line 216  Statement* Statements::statement(uint i) Line 240  Statement* Statements::statement(uint i)
240      return &*args.at(i);      return &*args.at(i);
241  }  }
242    
243    bool Statements::isPolyphonic() const {
244        for (int i = 0; i < args.size(); ++i)
245            if (args[i]->isPolyphonic())
246                return true;
247        return false;
248    }
249    
250    DynamicVariableCall::DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v)
251        : Variable(ctx, 0, false), dynVar(v), varName(name)
252    {
253    }
254    
255    int DynamicVariableCall::evalInt() {
256        VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
257        if (!expr) return 0;
258        return expr->evalInt();
259    }
260    
261    String DynamicVariableCall::evalStr() {
262        VMStringExpr* expr = dynamic_cast<VMStringExpr*>(dynVar);
263        if (!expr) return "";
264        return expr->evalStr();
265    }
266    
267    String DynamicVariableCall::evalCastToStr() {
268        if (dynVar->exprType() == STRING_EXPR) {
269            return evalStr();
270        } else {
271            VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(dynVar);
272            return intExpr ? ToString(intExpr->evalInt()) : "";
273        }
274    }
275    
276    void DynamicVariableCall::dump(int level) {
277        printIndents(level);
278        printf("Dynamic Variable '%s'\n", varName.c_str());
279    }
280    
281  void FunctionCall::dump(int level) {  void FunctionCall::dump(int level) {
282      printIndents(level);      printIndents(level);
283      printf("FunctionCall '%s' args={\n", functionName.c_str());      printf("FunctionCall '%s' args={\n", functionName.c_str());
# Line 274  String FunctionCall::evalCastToStr() { Line 336  String FunctionCall::evalCastToStr() {
336  IntVariable::IntVariable(ParserContext* ctx)  IntVariable::IntVariable(ParserContext* ctx)
337      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)      : Variable(ctx, ctx ? ctx->globalIntVarCount++ : 0, false), polyphonic(false)
338  {  {
339        //printf("globalIntVar parserctx=0x%lx memPOS=%d\n", ctx, memPos);
340        assert(ctx);
341    }
342    
343    inline static int postfixInc(int& object, int incBy) {
344        const int i = object;
345        object += incBy;
346        return i;
347  }  }
348    
349  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)  IntVariable::IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size)
350      : Variable(ctx, !ctx ? 0 : polyphonic ? ctx->polyphonicIntVarCount += size : ctx->globalIntVarCount += size, bConst),      : Variable(ctx, !ctx ? 0 : polyphonic ? postfixInc(ctx->polyphonicIntVarCount, size) : postfixInc(ctx->globalIntVarCount, size), bConst),
351        polyphonic(polyphonic)        polyphonic(polyphonic)
352  {  {
353        //printf("InvVar size=%d parserCtx=0x%lx\n", size, (uint64_t)ctx);
354        if (polyphonic) {
355            //printf("polyIntVar memPOS=%d\n", memPos);
356            assert(ctx);
357        }
358  }  }
359    
360  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
# Line 293  void IntVariable::assign(Expression* exp Line 368  void IntVariable::assign(Expression* exp
368    
369  int IntVariable::evalInt() {  int IntVariable::evalInt() {
370      //printf("IntVariable::eval pos=%d\n", memPos);      //printf("IntVariable::eval pos=%d\n", memPos);
371      if (polyphonic)      if (polyphonic) {
372            //printf("evalInt() poly memPos=%d execCtx=0x%lx\n", memPos, (uint64_t)context->execContext);
373          return context->execContext->polyphonicIntMemory[memPos];          return context->execContext->polyphonicIntMemory[memPos];
374        }
375      return (*context->globalIntMemory)[memPos];      return (*context->globalIntMemory)[memPos];
376  }  }
377    
378  void IntVariable::dump(int level) {  void IntVariable::dump(int level) {
379      printIndents(level);      printIndents(level);
380      printf("IntVariable memPos=%d\n", memPos);      printf("IntVariable\n");
381        //printf("IntVariable memPos=%d\n", memPos);
382  }  }
383    
384  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)  //ConstIntVariable::ConstIntVariable(ParserContext* ctx, int value)
# Line 329  void ConstIntVariable::dump(int level) { Line 407  void ConstIntVariable::dump(int level) {
407      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%d\n", value);
408  }  }
409    
410    BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)
411        : IntVariable(NULL,false,false), name(name), ptr(ptr)
412    {
413    }
414    
415    void BuiltInIntVariable::assign(Expression* expr) {
416        IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
417        if (!valueExpr) return;
418        ptr->assign(valueExpr->evalInt());
419    }
420    
421    int BuiltInIntVariable::evalInt() {
422        return ptr->evalInt();
423    }
424    
425    void BuiltInIntVariable::dump(int level) {
426        printIndents(level);
427        printf("Built-in IntVar '%s'\n", name.c_str());
428    }
429    
430  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
431      : IntVariable(ctx,true,false)      : IntVariable(ctx,true,false)
432  {  {
# Line 356  IntArrayVariable::IntArrayVariable(Parse Line 454  IntArrayVariable::IntArrayVariable(Parse
454      }      }
455  }  }
456    
457    IntArrayVariable::IntArrayVariable(ParserContext* ctx, bool bConst)
458        : Variable(ctx, 0, bConst)
459    {
460    }
461    
462  int IntArrayVariable::evalIntElement(uint i) {  int IntArrayVariable::evalIntElement(uint i) {
463      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
464      return values[i];      return values[i];
# Line 380  void IntArrayVariable::dump(int level) { Line 483  void IntArrayVariable::dump(int level) {
483      printf(")\n");      printf(")\n");
484  }  }
485    
486    BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)
487        : IntArrayVariable(NULL, false), name(name), array(array)
488    {
489    }
490    
491    int BuiltInIntArrayVariable::evalIntElement(uint i) {
492        return i >= array->size ? 0 : array->data[i];
493    }
494    
495    void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {
496        if (i >= array->size) return;
497        array->data[i] = value;
498    }
499    
500    void BuiltInIntArrayVariable::dump(int level) {
501        printIndents(level);
502        printf("Built-In Int Array Variable '%s'\n", name.c_str());
503    }
504    
505  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)
506      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
507  {      {    
# Line 477  Statements* If::branch(uint i) const { Line 599  Statements* If::branch(uint i) const {
599      return NULL;      return NULL;
600  }  }
601    
602    bool If::isPolyphonic() const {
603        if (condition->isPolyphonic() || ifStatements->isPolyphonic())
604            return true;
605        return elseStatements ? elseStatements->isPolyphonic() : false;
606    }
607    
608  void SelectCase::dump(int level) {  void SelectCase::dump(int level) {
609      printIndents(level);      printIndents(level);
610      if (select)      if (select)
# Line 527  Statements* SelectCase::branch(uint i) c Line 655  Statements* SelectCase::branch(uint i) c
655      return NULL;      return NULL;
656  }  }
657    
658    bool SelectCase::isPolyphonic() const {
659        if (select->isPolyphonic()) return true;
660        for (int i = 0; i < branches.size(); ++i)
661            if (branches[i].statements->isPolyphonic())
662                return true;
663        return false;
664    }
665    
666  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
667  //     CaseBranchRef b = new CaseBranchRef;  //     CaseBranchRef b = new CaseBranchRef;
668  //     b->from = condition;  //     b->from = condition;
# Line 575  void Neg::dump(int level) { Line 711  void Neg::dump(int level) {
711  }  }
712    
713  String ConcatString::evalStr() {  String ConcatString::evalStr() {
714      return lhs->evalCastToStr() + rhs->evalCastToStr();      // temporaries required here to enforce the associative left (to right) order
715        String l = lhs->evalCastToStr();
716        String r = rhs->evalCastToStr();
717        return l + r;
718  }  }
719    
720  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 653  bool Relation::isConstExpr() const { Line 792  bool Relation::isConstExpr() const {
792    
793  int Or::evalInt() {  int Or::evalInt() {
794      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
795        if (pLHS->evalInt()) return 1;
796      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
797      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
798  }  }
799    
800  void Or::dump(int level) {  void Or::dump(int level) {
# Line 668  void Or::dump(int level) { Line 808  void Or::dump(int level) {
808      printf(")\n");      printf(")\n");
809  }  }
810    
811    int BitwiseOr::evalInt() {
812        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
813        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
814        return pLHS->evalInt() | pRHS->evalInt();
815    }
816    
817    void BitwiseOr::dump(int level) {
818        printIndents(level);
819        printf("BitwiseOr(\n");
820        lhs->dump(level+1);
821        printIndents(level);
822        printf(",\n");
823        rhs->dump(level+1);
824        printIndents(level);
825        printf(")\n");
826    }
827    
828  int And::evalInt() {  int And::evalInt() {
829      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
830      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      if (!pLHS->evalInt()) return 0;
831      return pLHS->evalInt() && pRHS->evalInt();      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
832        return (pRHS->evalInt()) ? 1 : 0;
833  }  }
834    
835  void And::dump(int level) {  void And::dump(int level) {
# Line 685  void And::dump(int level) { Line 843  void And::dump(int level) {
843      printf(")\n");      printf(")\n");
844  }  }
845    
846    int BitwiseAnd::evalInt() {
847        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
848        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
849        return pLHS->evalInt() & pRHS->evalInt();
850    }
851    
852    void BitwiseAnd::dump(int level) {
853        printIndents(level);
854        printf("BitwiseAnd(\n");
855        lhs->dump(level+1);
856        printIndents(level);
857        printf(",\n");
858        rhs->dump(level+1);
859        printIndents(level);
860        printf(")\n");
861    }
862    
863  void Not::dump(int level) {  void Not::dump(int level) {
864      printIndents(level);      printIndents(level);
865      printf("Not(\n");      printf("Not(\n");
# Line 693  void Not::dump(int level) { Line 868  void Not::dump(int level) {
868      printf(")\n");      printf(")\n");
869  }  }
870    
871    void BitwiseNot::dump(int level) {
872        printIndents(level);
873        printf("BitwiseNot(\n");
874        expr->dump(level+1);
875        printIndents(level);
876        printf(")\n");
877    }
878    
879  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
880      if (!vartable.count(name)) {      if (!vartable.count(name)) {
881          return VariableRef();          return VariableRef();
# Line 718  StringVariableRef ParserContext::globalS Line 901  StringVariableRef ParserContext::globalS
901      return globalVar(name);      return globalVar(name);
902  }  }
903    
904  void ParserContext::addErr(int line, const char* txt) {  ParserContext::~ParserContext() {
905        destroyScanner();
906        if (globalIntMemory) {
907            delete globalIntMemory;
908            globalIntMemory = NULL;
909        }
910    }
911    
912    void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
913      ParserIssue e;      ParserIssue e;
914      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
915      e.txt = txt;      e.txt = txt;
916      e.line = line;      e.firstLine = firstLine;
917      errors.push_back(e);      e.lastLine = lastLine;
918      issues.push_back(e);      e.firstColumn = firstColumn;
919        e.lastColumn = lastColumn;
920        vErrors.push_back(e);
921        vIssues.push_back(e);
922  }  }
923    
924  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
925      ParserIssue w;      ParserIssue w;
926      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
927      w.txt = txt;      w.txt = txt;
928      w.line = line;      w.firstLine = firstLine;
929      warnings.push_back(w);      w.lastLine = lastLine;
930      issues.push_back(w);      w.firstColumn = firstColumn;
931        w.lastColumn = lastColumn;
932        vWarnings.push_back(w);
933        vIssues.push_back(w);
934  }  }
935    
936  bool ParserContext::setPreprocessorCondition(const char* name) {  bool ParserContext::setPreprocessorCondition(const char* name) {
# Line 755  bool ParserContext::isPreprocessorCondit Line 952  bool ParserContext::isPreprocessorCondit
952      return userPreprocessorConditions.count(name);      return userPreprocessorConditions.count(name);
953  }  }
954    
955    std::vector<ParserIssue> ParserContext::issues() const {
956        return vIssues;
957    }
958    
959    std::vector<ParserIssue> ParserContext::errors() const {
960        return vErrors;
961    }
962    
963    std::vector<ParserIssue> ParserContext::warnings() const {
964        return vWarnings;
965    }
966    
967    VMEventHandler* ParserContext::eventHandler(uint index) {
968        if (!handlers) return NULL;
969        return handlers->eventHandler(index);
970    }
971    
972    VMEventHandler* ParserContext::eventHandlerByName(const String& name) {
973        if (!handlers) return NULL;
974        return handlers->eventHandlerByName(name);
975    }
976    
977    void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {
978        for (std::map<String,int>::const_iterator it = vars.begin();
979             it != vars.end(); ++it)
980        {
981            ConstIntVariableRef ref = new ConstIntVariable(it->second);
982            vartable[it->first] = ref;
983        }
984    }
985    
986    void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {
987        for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();
988             it != vars.end(); ++it)
989        {
990            BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
991            vartable[it->first] = ref;
992        }
993    }
994    
995    void ParserContext::registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars) {
996        for (std::map<String,VMInt8Array*>::const_iterator it = vars.begin();
997             it != vars.end(); ++it)
998        {
999            BuiltInIntArrayVariableRef ref = new BuiltInIntArrayVariable(it->first, it->second);
1000            vartable[it->first] = ref;
1001        }
1002    }
1003    
1004    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1005        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1006             it != vars.end(); ++it)
1007        {
1008            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1009            vartable[it->first] = ref;
1010        }
1011    }
1012    
1013  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2581  
changed lines
  Added in v.2945
  ViewVC Help
Powered by ViewVC