/[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 2942 by schoenebeck, Wed Jul 13 15:51:06 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 144  void Args::dump(int level) { Line 144  void Args::dump(int level) {
144      printf(")\n");      printf(")\n");
145  }  }
146    
147    bool Args::isPolyphonic() const {
148        for (int i = 0; i < args.size(); ++i)
149            if (args[i]->isPolyphonic())
150                return true;
151        return false;
152    }
153    
154  EventHandlers::EventHandlers() {  EventHandlers::EventHandlers() {
155      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);      //printf("EventHandlers::Constructor 0x%lx\n", (long long)this);
156  }  }
# Line 177  EventHandler* EventHandlers::eventHandle Line 184  EventHandler* EventHandlers::eventHandle
184      return const_cast<EventHandler*>(&*args.at(index));      return const_cast<EventHandler*>(&*args.at(index));
185  }  }
186    
187    bool EventHandlers::isPolyphonic() const {
188        for (int i = 0; i < args.size(); ++i)
189            if (args[i]->isPolyphonic())
190                return true;
191        return false;
192    }
193    
194  Assignment::Assignment(VariableRef variable, ExpressionRef value)  Assignment::Assignment(VariableRef variable, ExpressionRef value)
195     : variable(variable), value(value)     : variable(variable), value(value)
196  {  {
# Line 194  StmtFlags_t Assignment::exec() { Line 208  StmtFlags_t Assignment::exec() {
208      return STMT_SUCCESS;      return STMT_SUCCESS;
209  }  }
210    
211    EventHandler::EventHandler(StatementsRef statements) {
212        this->statements = statements;
213        usingPolyphonics = statements->isPolyphonic();
214    }
215    
216  void EventHandler::dump(int level) {  void EventHandler::dump(int level) {
217      printIndents(level);      printIndents(level);
218      printf("EventHandler {\n");      printf("EventHandler {\n");
# Line 217  Statement* Statements::statement(uint i) Line 236  Statement* Statements::statement(uint i)
236      return &*args.at(i);      return &*args.at(i);
237  }  }
238    
239    bool Statements::isPolyphonic() const {
240        for (int i = 0; i < args.size(); ++i)
241            if (args[i]->isPolyphonic())
242                return true;
243        return false;
244    }
245    
246    DynamicVariableCall::DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v)
247        : Variable(ctx, 0, false), dynVar(v), varName(name)
248    {
249    }
250    
251    int DynamicVariableCall::evalInt() {
252        VMIntExpr* expr = dynamic_cast<VMIntExpr*>(dynVar);
253        if (!expr) return 0;
254        return expr->evalInt();
255    }
256    
257    String DynamicVariableCall::evalStr() {
258        VMStringExpr* expr = dynamic_cast<VMStringExpr*>(dynVar);
259        if (!expr) return "";
260        return expr->evalStr();
261    }
262    
263    String DynamicVariableCall::evalCastToStr() {
264        if (dynVar->exprType() == STRING_EXPR) {
265            return evalStr();
266        } else {
267            VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(dynVar);
268            return intExpr ? ToString(intExpr->evalInt()) : "";
269        }
270    }
271    
272    void DynamicVariableCall::dump(int level) {
273        printIndents(level);
274        printf("Dynamic Variable '%s'\n", varName.c_str());
275    }
276    
277  void FunctionCall::dump(int level) {  void FunctionCall::dump(int level) {
278      printIndents(level);      printIndents(level);
279      printf("FunctionCall '%s' args={\n", functionName.c_str());      printf("FunctionCall '%s' args={\n", functionName.c_str());
# Line 537  Statements* If::branch(uint i) const { Line 594  Statements* If::branch(uint i) const {
594      return NULL;      return NULL;
595  }  }
596    
597    bool If::isPolyphonic() const {
598        if (condition->isPolyphonic() || ifStatements->isPolyphonic())
599            return true;
600        return elseStatements ? elseStatements->isPolyphonic() : false;
601    }
602    
603  void SelectCase::dump(int level) {  void SelectCase::dump(int level) {
604      printIndents(level);      printIndents(level);
605      if (select)      if (select)
# Line 587  Statements* SelectCase::branch(uint i) c Line 650  Statements* SelectCase::branch(uint i) c
650      return NULL;      return NULL;
651  }  }
652    
653    bool SelectCase::isPolyphonic() const {
654        if (select->isPolyphonic()) return true;
655        for (int i = 0; i < branches.size(); ++i)
656            if (branches[i].statements->isPolyphonic())
657                return true;
658        return false;
659    }
660    
661  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {  // void Case::addBranch(IntExprRef condition, StatementsRef statements) {
662  //     CaseBranchRef b = new CaseBranchRef;  //     CaseBranchRef b = new CaseBranchRef;
663  //     b->from = condition;  //     b->from = condition;
# Line 713  bool Relation::isConstExpr() const { Line 784  bool Relation::isConstExpr() const {
784    
785  int Or::evalInt() {  int Or::evalInt() {
786      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
787        if (pLHS->evalInt()) return 1;
788      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;
789      return pLHS->evalInt() || pRHS->evalInt();      return (pRHS->evalInt()) ? 1 : 0;
790  }  }
791    
792  void Or::dump(int level) {  void Or::dump(int level) {
# Line 728  void Or::dump(int level) { Line 800  void Or::dump(int level) {
800      printf(")\n");      printf(")\n");
801  }  }
802    
803    int BitwiseOr::evalInt() {
804        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
805        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
806        return pLHS->evalInt() | pRHS->evalInt();
807    }
808    
809    void BitwiseOr::dump(int level) {
810        printIndents(level);
811        printf("BitwiseOr(\n");
812        lhs->dump(level+1);
813        printIndents(level);
814        printf(",\n");
815        rhs->dump(level+1);
816        printIndents(level);
817        printf(")\n");
818    }
819    
820  int And::evalInt() {  int And::evalInt() {
821      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);      IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
822      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);;      if (!pLHS->evalInt()) return 0;
823      return pLHS->evalInt() && pRHS->evalInt();      IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
824        return (pRHS->evalInt()) ? 1 : 0;
825  }  }
826    
827  void And::dump(int level) {  void And::dump(int level) {
# Line 745  void And::dump(int level) { Line 835  void And::dump(int level) {
835      printf(")\n");      printf(")\n");
836  }  }
837    
838    int BitwiseAnd::evalInt() {
839        IntExpr* pLHS = dynamic_cast<IntExpr*>(&*lhs);
840        IntExpr* pRHS = dynamic_cast<IntExpr*>(&*rhs);
841        return pLHS->evalInt() & pRHS->evalInt();
842    }
843    
844    void BitwiseAnd::dump(int level) {
845        printIndents(level);
846        printf("BitwiseAnd(\n");
847        lhs->dump(level+1);
848        printIndents(level);
849        printf(",\n");
850        rhs->dump(level+1);
851        printIndents(level);
852        printf(")\n");
853    }
854    
855  void Not::dump(int level) {  void Not::dump(int level) {
856      printIndents(level);      printIndents(level);
857      printf("Not(\n");      printf("Not(\n");
# Line 753  void Not::dump(int level) { Line 860  void Not::dump(int level) {
860      printf(")\n");      printf(")\n");
861  }  }
862    
863    void BitwiseNot::dump(int level) {
864        printIndents(level);
865        printf("BitwiseNot(\n");
866        expr->dump(level+1);
867        printIndents(level);
868        printf(")\n");
869    }
870    
871  VariableRef ParserContext::variableByName(const String& name) {  VariableRef ParserContext::variableByName(const String& name) {
872      if (!vartable.count(name)) {      if (!vartable.count(name)) {
873          return VariableRef();          return VariableRef();
# Line 786  ParserContext::~ParserContext() { Line 901  ParserContext::~ParserContext() {
901      }      }
902  }  }
903    
904  void ParserContext::addErr(int line, const char* txt) {  void ParserContext::addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
905      ParserIssue e;      ParserIssue e;
906      e.type = PARSER_ERROR;      e.type = PARSER_ERROR;
907      e.txt = txt;      e.txt = txt;
908      e.line = line;      e.firstLine = firstLine;
909        e.lastLine = lastLine;
910        e.firstColumn = firstColumn;
911        e.lastColumn = lastColumn;
912      vErrors.push_back(e);      vErrors.push_back(e);
913      vIssues.push_back(e);      vIssues.push_back(e);
914  }  }
915    
916  void ParserContext::addWrn(int line, const char* txt) {  void ParserContext::addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt) {
917      ParserIssue w;      ParserIssue w;
918      w.type = PARSER_WARNING;      w.type = PARSER_WARNING;
919      w.txt = txt;      w.txt = txt;
920      w.line = line;      w.firstLine = firstLine;
921        w.lastLine = lastLine;
922        w.firstColumn = firstColumn;
923        w.lastColumn = lastColumn;
924      vWarnings.push_back(w);      vWarnings.push_back(w);
925      vIssues.push_back(w);      vIssues.push_back(w);
926  }  }
# Line 871  void ParserContext::registerBuiltInIntAr Line 992  void ParserContext::registerBuiltInIntAr
992          vartable[it->first] = ref;          vartable[it->first] = ref;
993      }      }
994  }  }
995    
996    void ParserContext::registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars) {
997        for (std::map<String,VMDynVar*>::const_iterator it = vars.begin();
998             it != vars.end(); ++it)
999        {
1000            DynamicVariableCallRef ref = new DynamicVariableCall(it->first, this, it->second);
1001            vartable[it->first] = ref;
1002        }
1003    }
1004    
1005  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.2594  
changed lines
  Added in v.2942
  ViewVC Help
Powered by ViewVC