/[svn]/linuxsampler/trunk/src/scriptvm/CoreVMFunctions.cpp

Diff of /linuxsampler/trunk/src/scriptvm/CoreVMFunctions.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 3076 by schoenebeck,
Thu Jan  5 18:00:52 2017 UTC
+revision 3221 by schoenebeck,
Fri May 26 18:30:42 2017 UTC
 Line 1
  /*
-  * Copyright (c) 2014-2015 Christian Schoenebeck
+  * Copyright (c) 2014-2017 Christian Schoenebeck
   *
   * http://www.linuxsampler.org
   *
 Line 10
  #include "CoreVMFunctions.h"
  #include <iostream>
+ #include <algorithm> // for std::sort()
  #include <math.h>
  #include <stdlib.h>
  #include "tree.h"
-Line 230 
 VMFnResult* CoreVMFunction_max::exec(VMF
+Line 231 
 VMFnResult* CoreVMFunction_max::exec(VMF
      return successResult(l > r ? l : r);
  }
+ ///////////////////////////////////////////////////////////////////////////
+ // built-in script function:  array_equal()
+ VMFnResult* CoreVMFunction_array_equal::exec(VMFnArgs* args) {
+     VMIntArrayExpr* l = args->arg(0)->asIntArray();
+     VMIntArrayExpr* r = args->arg(1)->asIntArray();
+     if (l->arraySize() != r->arraySize()) {
+         wrnMsg("array_equal(): the two arrays differ in size");
+         return successResult(0); // false
+     }
+     const int n = l->arraySize();
+     for (int i = 0; i < n; ++i)
+         if (l->evalIntElement(i) != r->evalIntElement(i))
+             return successResult(0); // false
+     return successResult(1); // true
+ }
+ ///////////////////////////////////////////////////////////////////////////
+ // built-in script function:  search()
+ ExprType_t CoreVMFunction_search::argType(int iArg) const {
+     return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
+ }
+ bool CoreVMFunction_search::acceptsArgType(int iArg, ExprType_t type) const {
+     if (iArg == 0)
+         return type == INT_ARR_EXPR;
+     else
+         return type == INT_EXPR;
+ }
+ VMFnResult* CoreVMFunction_search::exec(VMFnArgs* args) {
+     VMIntArrayExpr* a = args->arg(0)->asIntArray();
+     const int needle = args->arg(1)->asInt()->evalInt();
+     const int n = a->arraySize();
+     for (int i = 0; i < n; ++i)
+         if (a->evalIntElement(i) == needle)
+             return successResult(i);
+     return successResult(-1); // not found
+ }
+ ///////////////////////////////////////////////////////////////////////////
+ // built-in script function:  sort()
+ ExprType_t CoreVMFunction_sort::argType(int iArg) const {
+     return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
+ }
+ bool CoreVMFunction_sort::acceptsArgType(int iArg, ExprType_t type) const {
+     if (iArg == 0)
+         return type == INT_ARR_EXPR;
+     else
+         return type == INT_EXPR;
+ }
+ struct ArrElemPOD {
+     VMIntArrayExpr* m_array;
+     int m_index;
+ };
+ static inline void swap(class ArrElemRef& a, class ArrElemRef& b);
+ class ArrElemRef : protected ArrElemPOD {
+ public:
+     ArrElemRef() {
+         m_array = NULL;
+         m_index = 0;
+     }
+     ArrElemRef(VMIntArrayExpr* a, int index) {
+         m_array = a;
+         m_index = index;
+     }
+     inline ArrElemRef& operator=(const ArrElemRef& e) {
+         setValue(e.getValue());
+         return *this;
+     }
+     inline ArrElemRef& operator=(int val) {
+         setValue(val);
+         return *this;
+     }
+     inline bool operator==(const ArrElemRef& e) const {
+         if (m_index == e.m_index)
+             return true;
+         return getValue() == e.getValue();
+     }
+     inline bool operator==(int val) const {
+         return getValue() == val;
+     }
+     inline bool operator!=(const ArrElemRef& e) const {
+         return !(operator==(e));
+     }
+     inline bool operator!=(int val) const {
+         return !(operator==(val));
+     }
+     inline bool operator<(const ArrElemRef& e) const {
+         if (m_index == e.m_index)
+             return false;
+         return getValue() < e.getValue();
+     }
+     inline bool operator<(int val) const {
+         return getValue() < val;
+     }
+     inline bool operator>(const ArrElemRef& e) const {
+         if (m_index == e.m_index)
+             return false;
+         return getValue() > e.getValue();
+     }
+     inline bool operator>(int val) const {
+         return getValue() > val;
+     }
+     inline bool operator<=(const ArrElemRef& e) const {
+         if (m_index == e.m_index)
+             return true;
+         return getValue() <= e.getValue();
+     }
+     inline bool operator<=(int val) const {
+         return getValue() <= val;
+     }
+     inline bool operator>=(const ArrElemRef& e) const {
+         if (m_index == e.m_index)
+             return true;
+         return getValue() >= e.getValue();
+     }
+     inline bool operator>=(int val) const {
+         return getValue() >= val;
+     }
+     inline operator int() const {
+         return getValue();
+     }
+ protected:
+     inline int getValue() const {
+         return m_array->evalIntElement(m_index);
+     }
+     inline void setValue(int value) {
+         m_array->assignIntElement(m_index, value);
+     }
+     friend void swap(class ArrElemRef& a, class ArrElemRef& b);
+ };
+ class ArrElemPtr : protected ArrElemPOD {
+ public:
+     ArrElemPtr() {
+         m_array = NULL;
+         m_index = 0;
+     }
+     ArrElemPtr(VMIntArrayExpr* a, int index) {
+         m_array = a;
+         m_index = index;
+     }
+     inline ArrElemRef operator*() {
+         return *(ArrElemRef*)this;
+     }
+ };
+ static inline void swap(ArrElemRef& a, ArrElemRef& b) {
+     int valueA = a.getValue();
+     int valueB = b.getValue();
+     a.setValue(valueB);
+     b.setValue(valueA);
+ }
+ class ArrExprIter : public ArrElemPOD {
+ public:
+     typedef std::random_access_iterator_tag iterator_category;
+     typedef int value_type;
+     typedef ssize_t difference_type;
+     typedef ArrElemPtr pointer;
+     typedef ArrElemRef reference;
+     ArrExprIter(VMIntArrayExpr* a, int index) {
+         m_array = a;
+         m_index = index;
+     }
+     inline ArrElemRef operator*() {
+         return *(ArrElemRef*)this;
+     }
+     inline ArrExprIter& operator++() { // prefix increment
+         ++m_index;
+         return *this;
+     }
+     inline ArrExprIter& operator--() { // prefix decrement
+         --m_index;
+         return *this;
+     }
+     inline ArrExprIter operator++(int) { // postfix increment
+         ArrExprIter it = *this;
+         ++m_index;
+         return it;
+     }
+     inline ArrExprIter operator--(int) { // postfix decrement
+         ArrExprIter it = *this;
+         --m_index;
+         return it;
+     }
+     inline bool operator==(const ArrExprIter& other) const {
+         return m_index == other.m_index;
+     }
+     inline bool operator!=(const ArrExprIter& other) const {
+         return m_index != other.m_index;
+     }
+     inline bool operator<(const ArrExprIter& other) const {
+         return m_index < other.m_index;
+     }
+     inline bool operator>(const ArrExprIter& other) const {
+         return m_index > other.m_index;
+     }
+     inline bool operator<=(const ArrExprIter& other) const {
+         return m_index <= other.m_index;
+     }
+     inline bool operator>=(const ArrExprIter& other) const {
+         return m_index >= other.m_index;
+     }
+     inline difference_type operator+(const ArrExprIter& other) const {
+         return m_index + other.m_index;
+     }
+     inline difference_type operator-(const ArrExprIter& other) const {
+         return m_index - other.m_index;
+     }
+     inline ArrExprIter operator-(difference_type d) const {
+         return ArrExprIter(m_array, m_index - d);
+     }
+     inline ArrExprIter operator+(difference_type d) const {
+         return ArrExprIter(m_array, m_index + d);
+     }
+     inline ArrExprIter operator*(difference_type factor) const {
+         return ArrExprIter(m_array, m_index * factor);
+     }
+ };
+ struct DescArrExprSorter {
+     inline bool operator()(const int& a, const int& b) const {
+         return a > b;
+     }
+ };
+ VMFnResult* CoreVMFunction_sort::exec(VMFnArgs* args) {
+     VMIntArrayExpr* a = args->arg(0)->asIntArray();
+     bool bAscending =
+         (args->argsCount() < 2) ? true : !args->arg(1)->asInt()->evalInt();
+     int n = a->arraySize();
+     ArrExprIter itBegin(a, 0);
+     ArrExprIter itEnd(a, n);
+     if (bAscending) {
+         std::sort(itBegin, itEnd);
+     } else {
+         DescArrExprSorter sorter;
+         std::sort(itBegin, itEnd, sorter);
+     }
+     return successResult();
+ }
  } // namespace LinuxSampler

 Legend:



Removed from v.3076
 


changed lines


 
Added in v.3221
 Legend:



Removed from v.3076
 


changed lines


 
Added in v.3221
-Removed from v.3076
+Added in v.3221

	ViewVC Help
Powered by ViewVC