/[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 3260 by schoenebeck, Wed May 31 21:07:44 2017 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014 Christian Schoenebeck and Andreas Persson   * Copyright (c) 2014 - 2017 Christian Schoenebeck and Andreas Persson
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 35  String IntExpr::evalCastToStr() { Line 35  String IntExpr::evalCastToStr() {
35      return ToString(evalInt());      return ToString(evalInt());
36  }  }
37    
38    /*String IntArrayExpr::evalCastToStr() {
39        String s = "{";
40        for (int i = 0; i < arraySize(); ++i) {
41            int val = evalIntElement(i);
42            if (i) s += ",";
43            s += ToString(val);
44        }
45        s += "}";
46        return s;
47    }*/
48    
49  int IntLiteral::evalInt() {  int IntLiteral::evalInt() {
50      return value;      return value;
51  }  }
# Line 102  void Mul::dump(int level) { Line 113  void Mul::dump(int level) {
113    
114  int Div::evalInt() {  int Div::evalInt() {
115      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
116      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
117      return (pLHS && pRHS) ? pRHS->evalInt() == 0 ? 0 : pLHS->evalInt() / pRHS->evalInt() : 0;      if (!pLHS || !pRHS) return 0;
118        int l = pLHS->evalInt();
119        int r = pRHS->evalInt();
120        if (r == 0) return 0;
121        return l / r;
122  }  }
123    
124  void Div::dump(int level) {  void Div::dump(int level) {
# Line 144  void Args::dump(int level) { Line 159  void Args::dump(int level) {
159      printf(")\n");      printf(")\n");
160  }  }
161    
162    bool Args::isPolyphonic() const {
163        for (int i = 0; i < args.size(); ++i)
164            if (args[i]->isPolyphonic())
165                return true;
166        return false;
167    }
168    
169  EventHandlers::EventHandlers() {  EventHandlers::EventHandlers() {
170      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
171  }  }
# Line 177  EventHandler* EventHandlers::eventHandle Line 199  EventHandler* EventHandlers::eventHandle
199      return const_cast<EventHandler*>(&*args.at(index));      return const_cast<EventHandler*>(&*args.at(index));
200  }  }
201    
202    bool EventHandlers::isPolyphonic() const {
203        for (int i = 0; i < args.size(); ++i)
204            if (args[i]->isPolyphonic())
205                return true;
206        return false;
207    }
208    
209  Assignment::Assignment(VariableRef variable, ExpressionRef value)  Assignment::Assignment(VariableRef variable, ExpressionRef value)
210     : variable(variable), value(value)     : variable(variable), value(value)
211  {  {
# Line 194  StmtFlags_t Assignment::exec() { Line 223  StmtFlags_t Assignment::exec() {
223      return STMT_SUCCESS;      return STMT_SUCCESS;
224  }  }
225    
226    EventHandler::EventHandler(StatementsRef statements) {
227        this->statements = statements;
228        usingPolyphonics = statements->isPolyphonic();
229    }
230    
231  void EventHandler::dump(int level) {  void EventHandler::dump(int level) {
232      printIndents(level);      printIndents(level);
233      printf("EventHandler {\n");      printf("EventHandler {\n");
# Line 217  Statement* Statements::statement(uint i) Line 251  Statement* Statements::statement(uint i)
251      return &*args.at(i);      return &*args.at(i);
252  }  }
253    
254    bool Statements::isPolyphonic() const {
255        for (int i = 0; i < args.size(); ++i)
256            if (args[i]->isPolyphonic())
257                return true;
258        return false;
259    }
260    
261    DynamicVariableCall::DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v)
262        : Variable(ctx, 0, false), dynVar(v), varName(name)
263    {
264    }
265    
266    int DynamicVariableCall::evalInt() {
267        VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
268        if (!expr) return 0;
269        return expr->evalInt();
270    }
271    
272    String DynamicVariableCall::evalStr() {
273        VMStringExpr* expr = dynamic_cast<VMStringExpr*>(dynVar);
274        if (!expr) return "";
275        return expr->evalStr();
276    }
277    
278    String DynamicVariableCall::evalCastToStr() {
279        if (dynVar->exprType() == STRING_EXPR) {
280            return evalStr();
281        } else {
282            VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(dynVar);
283            return intExpr ? ToString(intExpr->evalInt()) : "";
284        }
285    }
286    
287    void DynamicVariableCall::dump(int level) {
288        printIndents(level);
289        printf("Dynamic Variable '%s'\n", varName.c_str());
290    }
291    
292  void FunctionCall::dump(int level) {  void FunctionCall::dump(int level) {
293      printIndents(level);      printIndents(level);
294      printf("FunctionCall '%s' args={\n", functionName.c_str());      printf("FunctionCall '%s' args={\n", functionName.c_str());
# Line 252  int FunctionCall::evalInt() { Line 324  int FunctionCall::evalInt() {
324      return intExpr->evalInt();      return intExpr->evalInt();
325  }  }
326    
327    VMIntArrayExpr* FunctionCall::asIntArray() const {
328        VMFnResult* result = const_cast<FunctionCall*>(this)->execVMFn();
329        if (!result) return 0;
330        VMIntArrayExpr* intArrExpr = dynamic_cast<VMIntArrayExpr*>(result->resultValue());
331        return intArrExpr;
332    }
333    
334  String FunctionCall::evalStr() {  String FunctionCall::evalStr() {
335      VMFnResult* result = execVMFn();      VMFnResult* result = execVMFn();
336      if (!result) return "";      if (!result) return "";
# Line 298  IntVariable::IntVariable(ParserContext* Line 377  IntVariable::IntVariable(ParserContext*
377    
378  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
379      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
380      if (intExpr)      if (intExpr) {
381          if (polyphonic)          if (polyphonic)
382              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
383          else          else
384              (*context->globalIntMemory)[memPos] = intExpr->evalInt();              (*context->globalIntMemory)[memPos] = intExpr->evalInt();
385        }
386  }  }
387    
388  int IntVariable::evalInt() {  int IntVariable::evalInt() {
# Line 316  int IntVariable::evalInt() { Line 396  int IntVariable::evalInt() {
396    
397  void IntVariable::dump(int level) {  void IntVariable::dump(int level) {
398      printIndents(level);      printIndents(level);
399        printf("IntVariable\n");
400      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
401  }  }
402    
# Line 382  IntArrayVariable::IntArrayVariable(Parse Line 463  IntArrayVariable::IntArrayVariable(Parse
463      memset(&values[0], 0, size * sizeof(int));      memset(&values[0], 0, size * sizeof(int));
464  }  }
465    
466  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values)  IntArrayVariable::IntArrayVariable(ParserContext* ctx, int size, ArgsRef values, bool _bConst)
467      : Variable(ctx, 0, false)      : Variable(ctx, 0, _bConst)
468  {  {
469      this->values.resize(size);      this->values.resize(size);
470      for (int i = 0; i < values->argsCount(); ++i) {      for (int i = 0; i < values->argsCount(); ++i) {
# Line 537  Statements* If::branch(uint i) const { Line 618  Statements* If::branch(uint i) const {
618      return NULL;      return NULL;
619  }  }
620    
621    bool If::isPolyphonic() const {
622        if (condition->isPolyphonic() || ifStatements->isPolyphonic())
623            return true;
624        return elseStatements ? elseStatements->isPolyphonic() : false;
625    }
626    
627  void SelectCase::dump(int level) {  void SelectCase::dump(int level) {
628      printIndents(level);      printIndents(level);
629      if (select)      if (select)
# Line 587  Statements* SelectCase::branch(uint i) c Line 674  Statements* SelectCase::branch(uint i) c
674      return NULL;      return NULL;
675  }  }
676    
677    bool SelectCase::isPolyphonic() const {
678        if (select->isPolyphonic()) return true;
679        for (int i = 0; i < branches.size(); ++i)
680            if (branches[i].statements->isPolyphonic())
681                return true;
682        return false;
683    }
684    
685  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
686  //     CaseBranchRef b = new CaseBranchRef;  //     CaseBranchRef b = new CaseBranchRef;
687  //     b->from = condition;  //     b->from = condition;
# Line 629  bool While::evalLoopStartCondition() { Line 724  bool While::evalLoopStartCondition() {
724      return m_condition->evalInt();      return m_condition->evalInt();
725  }  }
726    
727    void SyncBlock::dump(int level) {
728        printIndents(level);
729        printf("sync {\n");
730        m_statements->dump(level+1);
731        printIndents(level);
732        printf("}\n");
733    }
734    
735    Statements* SyncBlock::statements() const {
736        return (m_statements) ? const_cast<Statements*>( &*m_statements ) : NULL;
737    }
738    
739  void Neg::dump(int level) {  void Neg::dump(int level) {
740      printIndents(level);      printIndents(level);
741      printf("Negative Expr\n");      printf("Negative Expr\n");
742  }  }
743    
744  String ConcatString::evalStr() {  String ConcatString::evalStr() {
745      return lhs->evalCastToStr() + rhs->evalCastToStr();      // temporaries required here to enforce the associative left (to right) order
746        // ( required for GCC and Visual Studio, see:
747        //   http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
748        //   Personally I am not convinced that this is "not a bug" of the
749        //   compiler/STL implementation and the allegedly underlying "function call"
750        //   nature causing this is IMO no profound reason that the C++ language's
751        //   "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
752        String l = lhs->evalCastToStr();
753        String r = rhs->evalCastToStr();
754        return l + r;
755  }  }
756    
757  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 713  bool Relation::isConstExpr() const { Line 829  bool Relation::isConstExpr() const {
829    
830  int Or::evalInt() {  int Or::evalInt() {
831      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
832        if (pLHS->evalInt()) return 1;
833      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
834      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
835  }  }
836    
837  void Or::dump(int level) {  void Or::dump(int level) {
# Line 728  void Or::dump(int level) { Line 845  void Or::dump(int level) {
845      printf(")\n");      printf(")\n");
846  }  }
847    
848    int BitwiseOr::evalInt() {
849        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
850        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
851        return pLHS->evalInt() | pRHS->evalInt();
852    }
853    
854    void BitwiseOr::dump(int level) {
855        printIndents(level);
856        printf("BitwiseOr(\n");
857        lhs->dump(level+1);
858        printIndents(level);
859        printf(",\n");
860        rhs->dump(level+1);
861        printIndents(level);
862        printf(")\n");
863    }
864    
865  int And::evalInt() {  int And::evalInt() {
866      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
867      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      if (!pLHS->evalInt()) return 0;
868      return pLHS->evalInt() && pRHS->evalInt();      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
869        return (pRHS->evalInt()) ? 1 : 0;
870  }  }
871    
872  void And::dump(int level) {  void And::dump(int level) {
# Line 745  void And::dump(int level) { Line 880  void And::dump(int level) {
880      printf(")\n");      printf(")\n");
881  }  }
882    
883    int BitwiseAnd::evalInt() {
884        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
885        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
886        return pLHS->evalInt() & pRHS->evalInt();
887    }
888    
889    void BitwiseAnd::dump(int level) {
890        printIndents(level);
891        printf("BitwiseAnd(\n");
892        lhs->dump(level+1);
893        printIndents(level);
894        printf(",\n");
895        rhs->dump(level+1);
896        printIndents(level);
897        printf(")\n");
898    }
899    
900  void Not::dump(int level) {  void Not::dump(int level) {
901      printIndents(level);      printIndents(level);
902      printf("Not(\n");      printf("Not(\n");
# Line 753  void Not::dump(int level) { Line 905  void Not::dump(int level) {
905      printf(")\n");      printf(")\n");
906  }  }
907    
908    void BitwiseNot::dump(int level) {
909        printIndents(level);
910        printf("BitwiseNot(\n");
911        expr->dump(level+1);
912        printIndents(level);
913        printf(")\n");
914    }
915    
916    StatementsRef ParserContext::userFunctionByName(const String& name) {
917        if (!userFnTable.count(name)) {
918            return StatementsRef();
919        }
920        return userFnTable.find(name)->second;
921    }
922    
923  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
924      if (!vartable.count(name)) {      if (!vartable.count(name)) {
925          return VariableRef();          return VariableRef();
# Line 786  ParserContext::~ParserContext() { Line 953  ParserContext::~ParserContext() {
953      }      }
954  }  }
955    
956  void ParserContext::addErr(int line, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
957      ParserIssue e;      ParserIssue e;
958      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
959      e.txt = txt;      e.txt = txt;
960      e.line = line;      e.firstLine = firstLine;
961        e.lastLine = lastLine;
962        e.firstColumn = firstColumn;
963        e.lastColumn = lastColumn;
964      vErrors.push_back(e);      vErrors.push_back(e);
965      vIssues.push_back(e);      vIssues.push_back(e);
966  }  }
967    
968  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
969      ParserIssue w;      ParserIssue w;
970      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
971      w.txt = txt;      w.txt = txt;
972      w.line = line;      w.firstLine = firstLine;
973        w.lastLine = lastLine;
974        w.firstColumn = firstColumn;
975        w.lastColumn = lastColumn;
976      vWarnings.push_back(w);      vWarnings.push_back(w);
977      vIssues.push_back(w);      vIssues.push_back(w);
978  }  }
# Line 871  void ParserContext::registerBuiltInIntAr Line 1044  void ParserContext::registerBuiltInIntAr
1044          vartable[it->first] = ref;          vartable[it->first] = ref;
1045      }      }
1046  }  }
1047    
1048    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1049        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1050             it != vars.end(); ++it)
1051        {
1052            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1053            vartable[it->first] = ref;
1054        }
1055    }
1056    
1057  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2594  
changed lines
  Added in v.3260
  ViewVC Help
Powered by ViewVC