/[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 2888 by schoenebeck, Sun Apr 24 18:16:10 2016 UTC revision 3056 by schoenebeck, Fri Dec 16 12:57:59 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 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 243  bool Statements::isPolyphonic() const { Line 258  bool Statements::isPolyphonic() const {
258      return false;      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 278  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 324  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 342  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 675  void Neg::dump(int level) { Line 730  void Neg::dump(int level) {
730  }  }
731    
732  String ConcatString::evalStr() {  String ConcatString::evalStr() {
733      return lhs->evalCastToStr() + rhs->evalCastToStr();      // temporaries required here to enforce the associative left (to right) order
734        // ( required for GCC and Visual Studio, see:
735        //   http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
736        //   Personally I am not convinced that this is "not a bug" of the
737        //   compiler/STL implementation and the allegedly underlying "function call"
738        //   nature causing this is IMO no profound reason that the C++ language's
739        //   "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
740        String l = lhs->evalCastToStr();
741        String r = rhs->evalCastToStr();
742        return l + r;
743  }  }
744    
745  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 769  void Or::dump(int level) { Line 833  void Or::dump(int level) {
833      printf(")\n");      printf(")\n");
834  }  }
835    
836    int BitwiseOr::evalInt() {
837        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
838        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
839        return pLHS->evalInt() | pRHS->evalInt();
840    }
841    
842    void BitwiseOr::dump(int level) {
843        printIndents(level);
844        printf("BitwiseOr(\n");
845        lhs->dump(level+1);
846        printIndents(level);
847        printf(",\n");
848        rhs->dump(level+1);
849        printIndents(level);
850        printf(")\n");
851    }
852    
853  int And::evalInt() {  int And::evalInt() {
854      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
855      if (!pLHS->evalInt()) return 0;      if (!pLHS->evalInt()) return 0;
# Line 787  void And::dump(int level) { Line 868  void And::dump(int level) {
868      printf(")\n");      printf(")\n");
869  }  }
870    
871    int BitwiseAnd::evalInt() {
872        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
873        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
874        return pLHS->evalInt() & pRHS->evalInt();
875    }
876    
877    void BitwiseAnd::dump(int level) {
878        printIndents(level);
879        printf("BitwiseAnd(\n");
880        lhs->dump(level+1);
881        printIndents(level);
882        printf(",\n");
883        rhs->dump(level+1);
884        printIndents(level);
885        printf(")\n");
886    }
887    
888  void Not::dump(int level) {  void Not::dump(int level) {
889      printIndents(level);      printIndents(level);
890      printf("Not(\n");      printf("Not(\n");
# Line 795  void Not::dump(int level) { Line 893  void Not::dump(int level) {
893      printf(")\n");      printf(")\n");
894  }  }
895    
896    void BitwiseNot::dump(int level) {
897        printIndents(level);
898        printf("BitwiseNot(\n");
899        expr->dump(level+1);
900        printIndents(level);
901        printf(")\n");
902    }
903    
904    StatementsRef ParserContext::userFunctionByName(const String& name) {
905        if (!userFnTable.count(name)) {
906            return StatementsRef();
907        }
908        return userFnTable.find(name)->second;
909    }
910    
911  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
912      if (!vartable.count(name)) {      if (!vartable.count(name)) {
913          return VariableRef();          return VariableRef();
# Line 828  ParserContext::~ParserContext() { Line 941  ParserContext::~ParserContext() {
941      }      }
942  }  }
943    
944  void ParserContext::addErr(int line, int column, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
945      ParserIssue e;      ParserIssue e;
946      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
947      e.txt = txt;      e.txt = txt;
948      e.line = line;      e.firstLine = firstLine;
949      e.column = column;      e.lastLine = lastLine;
950        e.firstColumn = firstColumn;
951        e.lastColumn = lastColumn;
952      vErrors.push_back(e);      vErrors.push_back(e);
953      vIssues.push_back(e);      vIssues.push_back(e);
954  }  }
955    
956  void ParserContext::addWrn(int line, int column, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
957      ParserIssue w;      ParserIssue w;
958      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
959      w.txt = txt;      w.txt = txt;
960      w.line = line;      w.firstLine = firstLine;
961      w.column = column;      w.lastLine = lastLine;
962        w.firstColumn = firstColumn;
963        w.lastColumn = lastColumn;
964      vWarnings.push_back(w);      vWarnings.push_back(w);
965      vIssues.push_back(w);      vIssues.push_back(w);
966  }  }
# Line 915  void ParserContext::registerBuiltInIntAr Line 1032  void ParserContext::registerBuiltInIntAr
1032          vartable[it->first] = ref;          vartable[it->first] = ref;
1033      }      }
1034  }  }
1035    
1036    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1037        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1038             it != vars.end(); ++it)
1039        {
1040            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1041            vartable[it->first] = ref;
1042        }
1043    }
1044    
1045  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2888  
changed lines
  Added in v.3056
  ViewVC Help
Powered by ViewVC