/[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 2594 by schoenebeck, Thu Jun 5 00:16:25 2014 UTC revision 2948 by schoenebeck, Fri Jul 15 15:29:04 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 102  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 144  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 177  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 194  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 217  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 316  int IntVariable::evalInt() { Line 377  int IntVariable::evalInt() {
377    
378  void IntVariable::dump(int level) {  void IntVariable::dump(int level) {
379      printIndents(level);      printIndents(level);
380        printf("IntVariable\n");
381      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
382  }  }
383    
# Line 537  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 587  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 635  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        // ( required for GCC and Visual Studio, see:
716        //   http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
717        //   Personally I am not convinced that this is "not a bug" of the
718        //   compiler/STL implementation and the allegedly underlying "function call"
719        //   nature causing this is IMO no profound reason that the C++ language's
720        //   "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
721        String l = lhs->evalCastToStr();
722        String r = rhs->evalCastToStr();
723        return l + r;
724  }  }
725    
726  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 713  bool Relation::isConstExpr() const { Line 798  bool Relation::isConstExpr() const {
798    
799  int Or::evalInt() {  int Or::evalInt() {
800      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
801        if (pLHS->evalInt()) return 1;
802      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
803      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
804  }  }
805    
806  void Or::dump(int level) {  void Or::dump(int level) {
# Line 728  void Or::dump(int level) { Line 814  void Or::dump(int level) {
814      printf(")\n");      printf(")\n");
815  }  }
816    
817    int BitwiseOr::evalInt() {
818        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
819        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
820        return pLHS->evalInt() | pRHS->evalInt();
821    }
822    
823    void BitwiseOr::dump(int level) {
824        printIndents(level);
825        printf("BitwiseOr(\n");
826        lhs->dump(level+1);
827        printIndents(level);
828        printf(",\n");
829        rhs->dump(level+1);
830        printIndents(level);
831        printf(")\n");
832    }
833    
834  int And::evalInt() {  int And::evalInt() {
835      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
836      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      if (!pLHS->evalInt()) return 0;
837      return pLHS->evalInt() && pRHS->evalInt();      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
838        return (pRHS->evalInt()) ? 1 : 0;
839  }  }
840    
841  void And::dump(int level) {  void And::dump(int level) {
# Line 745  void And::dump(int level) { Line 849  void And::dump(int level) {
849      printf(")\n");      printf(")\n");
850  }  }
851    
852    int BitwiseAnd::evalInt() {
853        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
854        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
855        return pLHS->evalInt() & pRHS->evalInt();
856    }
857    
858    void BitwiseAnd::dump(int level) {
859        printIndents(level);
860        printf("BitwiseAnd(\n");
861        lhs->dump(level+1);
862        printIndents(level);
863        printf(",\n");
864        rhs->dump(level+1);
865        printIndents(level);
866        printf(")\n");
867    }
868    
869  void Not::dump(int level) {  void Not::dump(int level) {
870      printIndents(level);      printIndents(level);
871      printf("Not(\n");      printf("Not(\n");
# Line 753  void Not::dump(int level) { Line 874  void Not::dump(int level) {
874      printf(")\n");      printf(")\n");
875  }  }
876    
877    void BitwiseNot::dump(int level) {
878        printIndents(level);
879        printf("BitwiseNot(\n");
880        expr->dump(level+1);
881        printIndents(level);
882        printf(")\n");
883    }
884    
885  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
886      if (!vartable.count(name)) {      if (!vartable.count(name)) {
887          return VariableRef();          return VariableRef();
# Line 786  ParserContext::~ParserContext() { Line 915  ParserContext::~ParserContext() {
915      }      }
916  }  }
917    
918  void ParserContext::addErr(int line, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
919      ParserIssue e;      ParserIssue e;
920      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
921      e.txt = txt;      e.txt = txt;
922      e.line = line;      e.firstLine = firstLine;
923        e.lastLine = lastLine;
924        e.firstColumn = firstColumn;
925        e.lastColumn = lastColumn;
926      vErrors.push_back(e);      vErrors.push_back(e);
927      vIssues.push_back(e);      vIssues.push_back(e);
928  }  }
929    
930  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
931      ParserIssue w;      ParserIssue w;
932      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
933      w.txt = txt;      w.txt = txt;
934      w.line = line;      w.firstLine = firstLine;
935        w.lastLine = lastLine;
936        w.firstColumn = firstColumn;
937        w.lastColumn = lastColumn;
938      vWarnings.push_back(w);      vWarnings.push_back(w);
939      vIssues.push_back(w);      vIssues.push_back(w);
940  }  }
# Line 871  void ParserContext::registerBuiltInIntAr Line 1006  void ParserContext::registerBuiltInIntAr
1006          vartable[it->first] = ref;          vartable[it->first] = ref;
1007      }      }
1008  }  }
1009    
1010    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1011        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1012             it != vars.end(); ++it)
1013        {
1014            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1015            vartable[it->first] = ref;
1016        }
1017    }
1018    
1019  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2594  
changed lines
  Added in v.2948
  ViewVC Help
Powered by ViewVC