/[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 2588 by schoenebeck, Sun Jun 1 14:44:38 2014 UTC revision 3034 by schoenebeck, Mon Oct 31 00:05:00 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 298  IntVariable::IntVariable(ParserContext* Line 359  IntVariable::IntVariable(ParserContext*
359    
360  void IntVariable::assign(Expression* expr) {  void IntVariable::assign(Expression* expr) {
361      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);      IntExpr* intExpr = dynamic_cast<IntExpr*>(expr);
362      if (intExpr)      if (intExpr) {
363          if (polyphonic)          if (polyphonic)
364              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();              context->execContext->polyphonicIntMemory[memPos] = intExpr->evalInt();
365          else          else
366              (*context->globalIntMemory)[memPos] = intExpr->evalInt();              (*context->globalIntMemory)[memPos] = intExpr->evalInt();
367        }
368  }  }
369    
370  int IntVariable::evalInt() {  int IntVariable::evalInt() {
# Line 316  int IntVariable::evalInt() { Line 378  int IntVariable::evalInt() {
378    
379  void IntVariable::dump(int level) {  void IntVariable::dump(int level) {
380      printIndents(level);      printIndents(level);
381        printf("IntVariable\n");
382      //printf("IntVariable memPos=%d\n", memPos);      //printf("IntVariable memPos=%d\n", memPos);
383  }  }
384    
# Line 345  void ConstIntVariable::dump(int level) { Line 408  void ConstIntVariable::dump(int level) {
408      printf("ConstIntVariable val=%d\n", value);      printf("ConstIntVariable val=%d\n", value);
409  }  }
410    
411    BuiltInIntVariable::BuiltInIntVariable(const String& name, VMIntRelPtr* ptr)
412        : IntVariable(NULL,false,false), name(name), ptr(ptr)
413    {
414    }
415    
416    void BuiltInIntVariable::assign(Expression* expr) {
417        IntExpr* valueExpr = dynamic_cast<IntExpr*>(expr);
418        if (!valueExpr) return;
419        ptr->assign(valueExpr->evalInt());
420    }
421    
422    int BuiltInIntVariable::evalInt() {
423        return ptr->evalInt();
424    }
425    
426    void BuiltInIntVariable::dump(int level) {
427        printIndents(level);
428        printf("Built-in IntVar '%s'\n", name.c_str());
429    }
430    
431  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)  PolyphonicIntVariable::PolyphonicIntVariable(ParserContext* ctx)
432      : IntVariable(ctx,true,false)      : IntVariable(ctx,true,false)
433  {  {
# Line 372  IntArrayVariable::IntArrayVariable(Parse Line 455  IntArrayVariable::IntArrayVariable(Parse
455      }      }
456  }  }
457    
458    IntArrayVariable::IntArrayVariable(ParserContext* ctx, bool bConst)
459        : Variable(ctx, 0, bConst)
460    {
461    }
462    
463  int IntArrayVariable::evalIntElement(uint i) {  int IntArrayVariable::evalIntElement(uint i) {
464      if (i >= values.size()) return 0;      if (i >= values.size()) return 0;
465      return values[i];      return values[i];
# Line 396  void IntArrayVariable::dump(int level) { Line 484  void IntArrayVariable::dump(int level) {
484      printf(")\n");      printf(")\n");
485  }  }
486    
487    BuiltInIntArrayVariable::BuiltInIntArrayVariable(const String& name, VMInt8Array* array)
488        : IntArrayVariable(NULL, false), name(name), array(array)
489    {
490    }
491    
492    int BuiltInIntArrayVariable::evalIntElement(uint i) {
493        return i >= array->size ? 0 : array->data[i];
494    }
495    
496    void BuiltInIntArrayVariable::assignIntElement(uint i, int value) {
497        if (i >= array->size) return;
498        array->data[i] = value;
499    }
500    
501    void BuiltInIntArrayVariable::dump(int level) {
502        printIndents(level);
503        printf("Built-In Int Array Variable '%s'\n", name.c_str());
504    }
505    
506  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)  IntArrayElement::IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex)
507      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)      : IntVariable(NULL, false, false, 0), array(array), index(arrayIndex)
508  {      {    
# Line 493  Statements* If::branch(uint i) const { Line 600  Statements* If::branch(uint i) const {
600      return NULL;      return NULL;
601  }  }
602    
603    bool If::isPolyphonic() const {
604        if (condition->isPolyphonic() || ifStatements->isPolyphonic())
605            return true;
606        return elseStatements ? elseStatements->isPolyphonic() : false;
607    }
608    
609  void SelectCase::dump(int level) {  void SelectCase::dump(int level) {
610      printIndents(level);      printIndents(level);
611      if (select)      if (select)
# Line 543  Statements* SelectCase::branch(uint i) c Line 656  Statements* SelectCase::branch(uint i) c
656      return NULL;      return NULL;
657  }  }
658    
659    bool SelectCase::isPolyphonic() const {
660        if (select->isPolyphonic()) return true;
661        for (int i = 0; i < branches.size(); ++i)
662            if (branches[i].statements->isPolyphonic())
663                return true;
664        return false;
665    }
666    
667  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
668  //     CaseBranchRef b = new CaseBranchRef;  //     CaseBranchRef b = new CaseBranchRef;
669  //     b->from = condition;  //     b->from = condition;
# Line 591  void Neg::dump(int level) { Line 712  void Neg::dump(int level) {
712  }  }
713    
714  String ConcatString::evalStr() {  String ConcatString::evalStr() {
715      return lhs->evalCastToStr() + rhs->evalCastToStr();      // temporaries required here to enforce the associative left (to right) order
716        // ( required for GCC and Visual Studio, see:
717        //   http://stackoverflow.com/questions/25842902/why-stdstring-concatenation-operator-works-like-right-associative-one
718        //   Personally I am not convinced that this is "not a bug" of the
719        //   compiler/STL implementation and the allegedly underlying "function call"
720        //   nature causing this is IMO no profound reason that the C++ language's
721        //   "+" operator's left associativity is ignored. -- Christian, 2016-07-14 )
722        String l = lhs->evalCastToStr();
723        String r = rhs->evalCastToStr();
724        return l + r;
725  }  }
726    
727  void ConcatString::dump(int level) {  void ConcatString::dump(int level) {
# Line 669  bool Relation::isConstExpr() const { Line 799  bool Relation::isConstExpr() const {
799    
800  int Or::evalInt() {  int Or::evalInt() {
801      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
802        if (pLHS->evalInt()) return 1;
803      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
804      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
805  }  }
806    
807  void Or::dump(int level) {  void Or::dump(int level) {
# Line 684  void Or::dump(int level) { Line 815  void Or::dump(int level) {
815      printf(")\n");      printf(")\n");
816  }  }
817    
818    int BitwiseOr::evalInt() {
819        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
820        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
821        return pLHS->evalInt() | pRHS->evalInt();
822    }
823    
824    void BitwiseOr::dump(int level) {
825        printIndents(level);
826        printf("BitwiseOr(\n");
827        lhs->dump(level+1);
828        printIndents(level);
829        printf(",\n");
830        rhs->dump(level+1);
831        printIndents(level);
832        printf(")\n");
833    }
834    
835  int And::evalInt() {  int And::evalInt() {
836      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
837      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      if (!pLHS->evalInt()) return 0;
838      return pLHS->evalInt() && pRHS->evalInt();      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
839        return (pRHS->evalInt()) ? 1 : 0;
840  }  }
841    
842  void And::dump(int level) {  void And::dump(int level) {
# Line 701  void And::dump(int level) { Line 850  void And::dump(int level) {
850      printf(")\n");      printf(")\n");
851  }  }
852    
853    int BitwiseAnd::evalInt() {
854        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
855        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
856        return pLHS->evalInt() & pRHS->evalInt();
857    }
858    
859    void BitwiseAnd::dump(int level) {
860        printIndents(level);
861        printf("BitwiseAnd(\n");
862        lhs->dump(level+1);
863        printIndents(level);
864        printf(",\n");
865        rhs->dump(level+1);
866        printIndents(level);
867        printf(")\n");
868    }
869    
870  void Not::dump(int level) {  void Not::dump(int level) {
871      printIndents(level);      printIndents(level);
872      printf("Not(\n");      printf("Not(\n");
# Line 709  void Not::dump(int level) { Line 875  void Not::dump(int level) {
875      printf(")\n");      printf(")\n");
876  }  }
877    
878    void BitwiseNot::dump(int level) {
879        printIndents(level);
880        printf("BitwiseNot(\n");
881        expr->dump(level+1);
882        printIndents(level);
883        printf(")\n");
884    }
885    
886    StatementsRef ParserContext::userFunctionByName(const String& name) {
887        if (!userFnTable.count(name)) {
888            return StatementsRef();
889        }
890        return userFnTable.find(name)->second;
891    }
892    
893  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
894      if (!vartable.count(name)) {      if (!vartable.count(name)) {
895          return VariableRef();          return VariableRef();
# Line 742  ParserContext::~ParserContext() { Line 923  ParserContext::~ParserContext() {
923      }      }
924  }  }
925    
926  void ParserContext::addErr(int line, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
927      ParserIssue e;      ParserIssue e;
928      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
929      e.txt = txt;      e.txt = txt;
930      e.line = line;      e.firstLine = firstLine;
931        e.lastLine = lastLine;
932        e.firstColumn = firstColumn;
933        e.lastColumn = lastColumn;
934      vErrors.push_back(e);      vErrors.push_back(e);
935      vIssues.push_back(e);      vIssues.push_back(e);
936  }  }
937    
938  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
939      ParserIssue w;      ParserIssue w;
940      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
941      w.txt = txt;      w.txt = txt;
942      w.line = line;      w.firstLine = firstLine;
943        w.lastLine = lastLine;
944        w.firstColumn = firstColumn;
945        w.lastColumn = lastColumn;
946      vWarnings.push_back(w);      vWarnings.push_back(w);
947      vIssues.push_back(w);      vIssues.push_back(w);
948  }  }
# Line 801  VMEventHandler* ParserContext::eventHand Line 988  VMEventHandler* ParserContext::eventHand
988      return handlers->eventHandlerByName(name);      return handlers->eventHandlerByName(name);
989  }  }
990    
991    void ParserContext::registerBuiltInConstIntVariables(const std::map<String,int>& vars) {
992        for (std::map<String,int>::const_iterator it = vars.begin();
993             it != vars.end(); ++it)
994        {
995            ConstIntVariableRef ref = new ConstIntVariable(it->second);
996            vartable[it->first] = ref;
997        }
998    }
999    
1000    void ParserContext::registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars) {
1001        for (std::map<String,VMIntRelPtr*>::const_iterator it = vars.begin();
1002             it != vars.end(); ++it)
1003        {
1004            BuiltInIntVariableRef ref = new BuiltInIntVariable(it->first, it->second);
1005            vartable[it->first] = ref;
1006        }
1007    }
1008    
1009    void ParserContext::registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars) {
1010        for (std::map<String,VMInt8Array*>::const_iterator it = vars.begin();
1011             it != vars.end(); ++it)
1012        {
1013            BuiltInIntArrayVariableRef ref = new BuiltInIntArrayVariable(it->first, it->second);
1014            vartable[it->first] = ref;
1015        }
1016    }
1017    
1018    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
1019        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
1020             it != vars.end(); ++it)
1021        {
1022            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1023            vartable[it->first] = ref;
1024        }
1025    }
1026    
1027  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2588  
changed lines
  Added in v.3034
  ViewVC Help
Powered by ViewVC