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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3222 by schoenebeck, Fri May 26 18:55:45 2017 UTC revision 3577 by schoenebeck, Wed Aug 28 15:23:23 2019 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014-2017 Christian Schoenebeck   * Copyright (c) 2014-2019 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 15  Line 15 
15  #include <stdlib.h>  #include <stdlib.h>
16  #include "tree.h"  #include "tree.h"
17  #include "ScriptVM.h"  #include "ScriptVM.h"
18    #include "../common/RTMath.h"
19    
20  namespace LinuxSampler {  namespace LinuxSampler {
21    
# Line 34  VMFnResult* VMEmptyResultFunction::succe Line 35  VMFnResult* VMEmptyResultFunction::succe
35  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
36  // class VMIntResultFunction  // class VMIntResultFunction
37    
38  VMFnResult* VMIntResultFunction::errorResult(int i) {  VMFnResult* VMIntResultFunction::errorResult(vmint i) {
39      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
40      result.value = i;      result.value = i;
41      return &result;      return &result;
42  }  }
43    
44  VMFnResult* VMIntResultFunction::successResult(int i) {  VMFnResult* VMIntResultFunction::successResult(vmint i) {
45      result.flags = STMT_SUCCESS;      result.flags = STMT_SUCCESS;
46      result.value = i;      result.value = i;
47      return &result;      return &result;
48  }  }
49    
50  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
51    // class VMRealResultFunction
52    
53    VMFnResult* VMRealResultFunction::errorResult(vmfloat f) {
54        result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
55        result.value = f;
56        return &result;
57    }
58    
59    VMFnResult* VMRealResultFunction::successResult(vmfloat f) {
60        result.flags = STMT_SUCCESS;
61        result.value = f;
62        return &result;
63    }
64    
65    ///////////////////////////////////////////////////////////////////////////
66  // class VMStringResultFunction  // class VMStringResultFunction
67    
68  VMFnResult* VMStringResultFunction::errorResult(const String& s) {  VMFnResult* VMStringResultFunction::errorResult(const String& s) {
# Line 62  VMFnResult* VMStringResultFunction::succ Line 78  VMFnResult* VMStringResultFunction::succ
78  }  }
79    
80  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
81    // class VMScalarNumberResultFunction
82    
83    VMFnResult* VMScalarNumberResultFunction::errorResult(vmint i) {
84        intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
85        intResult.value = i;
86        return &intResult;
87    }
88    
89    VMFnResult* VMScalarNumberResultFunction::errorResult(vmfloat f) {
90        realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
91        realResult.value = f;
92        return &realResult;
93    }
94    
95    VMFnResult* VMScalarNumberResultFunction::successResult(vmint i) {
96        intResult.flags = STMT_SUCCESS;
97        intResult.value = i;
98        return &intResult;
99    }
100    
101    VMFnResult* VMScalarNumberResultFunction::successResult(vmfloat f) {
102        realResult.flags = STMT_SUCCESS;
103        realResult.value = f;
104        return &realResult;
105    }
106    
107    ///////////////////////////////////////////////////////////////////////////
108  // built-in script function:  message()  // built-in script function:  message()
109    
110  bool CoreVMFunction_message::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_message::acceptsArgType(vmint iArg, ExprType_t type) const {
111      return type == INT_EXPR || type == STRING_EXPR;      return type == INT_EXPR || type == REAL_EXPR || type == STRING_EXPR;
112  }  }
113    
114  VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {
115      if (!args->argsCount()) return errorResult();      if (!args->argsCount()) return errorResult();
116    
117        uint64_t usecs = RTMath::unsafeMicroSeconds(RTMath::real_clock);
118    
119      VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));      VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));
120      if (strExpr) {      if (strExpr) {
121          std::cout << "[ScriptVM] " << strExpr->evalStr() << "\n";          printf("[ScriptVM %.3f] %s\n", usecs/1000000.f, strExpr->evalStr().c_str());
122            return successResult();
123        }
124    
125        VMRealExpr* realExpr = dynamic_cast<VMRealExpr*>(args->arg(0));
126        if (realExpr) {
127            printf("[ScriptVM %.3f] %f\n", usecs/1000000.f, realExpr->evalReal());
128          return successResult();          return successResult();
129      }      }
130    
131      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
132      if (intExpr) {      if (intExpr) {
133          std::cout << "[ScriptVM] " << intExpr->evalInt() << "\n";          printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());
134          return successResult();          return successResult();
135      }      }
136    
# Line 89  VMFnResult* CoreVMFunction_message::exec Line 140  VMFnResult* CoreVMFunction_message::exec
140  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
141  // built-in script function:  exit()  // built-in script function:  exit()
142    
143    vmint CoreVMFunction_exit::maxAllowedArgs() const {
144        return (vm->isExitResultEnabled()) ? 1 : 0;
145    }
146    
147    bool CoreVMFunction_exit::acceptsArgType(vmint iArg, ExprType_t type) const {
148        if (!vm->isExitResultEnabled()) return false;
149        return type == INT_EXPR || type == REAL_EXPR || type == STRING_EXPR;
150    }
151    
152  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
153      this->result.flags = STMT_ABORT_SIGNALLED;      this->result.flags = STMT_ABORT_SIGNALLED;
154        if (vm->isExitResultEnabled() && args->argsCount()) {
155            ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
156            switch (args->arg(0)->exprType()) {
157                case INT_EXPR:
158                    ctx->exitRes.intLiteral.value = args->arg(0)->asInt()->evalInt();
159                    ctx->exitRes.value = &ctx->exitRes.intLiteral;
160                    break;
161                case REAL_EXPR:
162                    ctx->exitRes.realLiteral.value = args->arg(0)->asReal()->evalReal();
163                    ctx->exitRes.value = &ctx->exitRes.realLiteral;
164                    break;
165                case STRING_EXPR:
166                    ctx->exitRes.stringLiteral.value = args->arg(0)->asString()->evalStr();
167                    ctx->exitRes.value = &ctx->exitRes.stringLiteral;
168                    break;
169                default:
170                    ; // noop - just to shut up the compiler
171            }
172        }
173      return &result;      return &result;
174  }  }
175    
176  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
177  // built-in script function:  wait()  // built-in script function:  wait()
178    
179    bool CoreVMFunction_wait::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
180        if (iArg == 0)
181            return type == VM_NO_UNIT || type == VM_SECOND;
182        else
183            return type == VM_NO_UNIT;
184    }
185    
186    bool CoreVMFunction_wait::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
187        return iArg == 0 && type == VM_SECOND;
188    }
189    
190  VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {
191      ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());      ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
192      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));      VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));
193      int us = expr->evalInt();      StdUnit_t unit = expr->unitType();
194        vmint us = (unit) ? expr->evalInt(VM_MICRO) : expr->evalInt();
195      if (us < 0) {      if (us < 0) {
196          wrnMsg("wait(): argument may not be negative! Aborting script!");          wrnMsg("wait(): argument may not be negative! Aborting script!");
197          this->result.flags = STMT_ABORT_SIGNALLED;          this->result.flags = STMT_ABORT_SIGNALLED;
# Line 117  VMFnResult* CoreVMFunction_wait::exec(VM Line 208  VMFnResult* CoreVMFunction_wait::exec(VM
208  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
209  // built-in script function:  abs()  // built-in script function:  abs()
210    
211  bool CoreVMFunction_abs::acceptsArgType(int iArg, ExprType_t type) const {  ExprType_t CoreVMFunction_abs::returnType(VMFnArgs* args) {
212      return type == INT_EXPR;      return args->arg(0)->exprType();
213    }
214    
215    bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {
216        return type == INT_EXPR || type == REAL_EXPR;
217  }  }
218    
219  VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {
220      return successResult( ::abs(args->arg(0)->asInt()->evalInt()) );      VMExpr* arg = args->arg(0);
221        if (arg->exprType() == REAL_EXPR)
222            return successResult( ::fabs(arg->asReal()->evalReal()) );
223        else
224            return successResult( ::abs(arg->asInt()->evalInt()) );
225  }  }
226    
227  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
228  // built-in script function:  random()  // built-in script function:  random()
229    
230  bool CoreVMFunction_random::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_random::acceptsArgType(vmint iArg, ExprType_t type) const {
231      return type == INT_EXPR;      return type == INT_EXPR;
232  }  }
233    
234  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {
235      int iMin = args->arg(0)->asInt()->evalInt();      vmint iMin = args->arg(0)->asInt()->evalInt();
236      int iMax = args->arg(1)->asInt()->evalInt();      vmint iMax = args->arg(1)->asInt()->evalInt();
237      float f = float(::rand()) / float(RAND_MAX);      float f = float(::rand()) / float(RAND_MAX);
238      return successResult(      return successResult(
239          iMin + roundf( f * float(iMax - iMin) )          iMin + roundf( f * float(iMax - iMin) )
# Line 144  VMFnResult* CoreVMFunction_random::exec( Line 243  VMFnResult* CoreVMFunction_random::exec(
243  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
244  // built-in script function:  num_elements()  // built-in script function:  num_elements()
245    
246  bool CoreVMFunction_num_elements::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_num_elements::acceptsArgType(vmint iArg, ExprType_t type) const {
247      return type == INT_ARR_EXPR;      return type == INT_ARR_EXPR;
248  }  }
249    
# Line 160  VMFnResult* CoreVMFunction_inc::exec(VMF Line 259  VMFnResult* CoreVMFunction_inc::exec(VMF
259      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
260      VMVariable* out = dynamic_cast<VMVariable*>(arg);      VMVariable* out = dynamic_cast<VMVariable*>(arg);
261      if (!in || !out) successResult(0);      if (!in || !out) successResult(0);
262      int i = in->evalInt() + 1;      vmint i = in->evalInt() + 1;
263      IntLiteral tmp(i);      IntLiteral tmp(i);
264      out->assignExpr(&tmp);      out->assignExpr(&tmp);
265      return successResult(i);      return successResult(i);
# Line 174  VMFnResult* CoreVMFunction_dec::exec(VMF Line 273  VMFnResult* CoreVMFunction_dec::exec(VMF
273      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);      VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
274      VMVariable* out = dynamic_cast<VMVariable*>(arg);      VMVariable* out = dynamic_cast<VMVariable*>(arg);
275      if (!in || !out) successResult(0);      if (!in || !out) successResult(0);
276      int i = in->evalInt() - 1;      vmint i = in->evalInt() - 1;
277      IntLiteral tmp(i);      IntLiteral tmp(i);
278      out->assignExpr(&tmp);      out->assignExpr(&tmp);
279      return successResult(i);      return successResult(i);
# Line 184  VMFnResult* CoreVMFunction_dec::exec(VMF Line 283  VMFnResult* CoreVMFunction_dec::exec(VMF
283  // built-in script function:  in_range()  // built-in script function:  in_range()
284    
285  VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {
286      int i  = args->arg(0)->asInt()->evalInt();      vmint i  = args->arg(0)->asInt()->evalInt();
287      int lo = args->arg(1)->asInt()->evalInt();      vmint lo = args->arg(1)->asInt()->evalInt();
288      int hi = args->arg(2)->asInt()->evalInt();      vmint hi = args->arg(2)->asInt()->evalInt();
289      if (lo > hi) { // swap lo and hi      if (lo > hi) { // swap lo and hi
290          int tmp = lo;          vmint tmp = lo;
291          lo = hi;          lo = hi;
292          hi = tmp;          hi = tmp;
293      }      }
# Line 199  VMFnResult* CoreVMFunction_in_range::exe Line 298  VMFnResult* CoreVMFunction_in_range::exe
298  // built-in script function:  sh_left()  // built-in script function:  sh_left()
299    
300  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
301      int i = args->arg(0)->asInt()->evalInt();      vmint i = args->arg(0)->asInt()->evalInt();
302      int n = args->arg(1)->asInt()->evalInt();      vmint n = args->arg(1)->asInt()->evalInt();
303      return successResult(i << n);      return successResult(i << n);
304  }  }
305    
# Line 208  VMFnResult* CoreVMFunction_sh_left::exec Line 307  VMFnResult* CoreVMFunction_sh_left::exec
307  // built-in script function:  sh_right()  // built-in script function:  sh_right()
308    
309  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
310      int i = args->arg(0)->asInt()->evalInt();      vmint i = args->arg(0)->asInt()->evalInt();
311      int n = args->arg(1)->asInt()->evalInt();      vmint n = args->arg(1)->asInt()->evalInt();
312      return successResult(i >> n);      return successResult(i >> n);
313  }  }
314    
315  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
316  // built-in script function:  min()  // built-in script function:  min()
317    
318    ExprType_t CoreVMFunction_min::returnType(VMFnArgs* args) {
319        return (args->arg(0)->exprType() == REAL_EXPR ||
320                args->arg(1)->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
321    }
322    
323    bool CoreVMFunction_min::acceptsArgType(vmint iArg, ExprType_t type) const {
324        return type == INT_EXPR || type == REAL_EXPR;
325    }
326    
327  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
328      int l = args->arg(0)->asInt()->evalInt();      VMExpr* a = args->arg(0);
329      int r = args->arg(1)->asInt()->evalInt();      VMExpr* b = args->arg(1);
330      return successResult(l < r ? l : r);      if (a->exprType() == REAL_EXPR && b->exprType() == REAL_EXPR) {
331            vmfloat l = a->asReal()->evalReal();
332            vmfloat r = b->asReal()->evalReal();
333            return successResult(l < r ? l : r);
334        } else if (a->exprType() == REAL_EXPR && b->exprType() == INT_EXPR) {
335            vmfloat l = a->asReal()->evalReal();
336            vmint   r = b->asInt()->evalInt();
337            return successResult(l < r ? l : r);
338        } else if (a->exprType() == INT_EXPR && b->exprType() == REAL_EXPR) {
339            vmint   l = a->asInt()->evalInt();
340            vmfloat r = b->asReal()->evalReal();
341            return successResult(l < r ? l : r);
342        } else {
343            vmint l = a->asInt()->evalInt();
344            vmint r = b->asInt()->evalInt();
345            return successResult(l < r ? l : r);
346        }
347  }  }
348    
349  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
350  // built-in script function:  max()  // built-in script function:  max()
351    
352    ExprType_t CoreVMFunction_max::returnType(VMFnArgs* args) {
353        return (args->arg(0)->exprType() == REAL_EXPR ||
354                args->arg(1)->exprType() == REAL_EXPR) ? REAL_EXPR : INT_EXPR;
355    }
356    
357    bool CoreVMFunction_max::acceptsArgType(vmint iArg, ExprType_t type) const {
358        return type == INT_EXPR || type == REAL_EXPR;
359    }
360    
361  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
362      int l = args->arg(0)->asInt()->evalInt();      VMExpr* a = args->arg(0);
363      int r = args->arg(1)->asInt()->evalInt();      VMExpr* b = args->arg(1);
364      return successResult(l > r ? l : r);      if (a->exprType() == REAL_EXPR && b->exprType() == REAL_EXPR) {
365            vmfloat l = a->asReal()->evalReal();
366            vmfloat r = b->asReal()->evalReal();
367            return successResult(l > r ? l : r);
368        } else if (a->exprType() == REAL_EXPR && b->exprType() == INT_EXPR) {
369            vmfloat l = a->asReal()->evalReal();
370            vmint   r = b->asInt()->evalInt();
371            return successResult(l > r ? l : r);
372        } else if (a->exprType() == INT_EXPR && b->exprType() == REAL_EXPR) {
373            vmint   l = a->asInt()->evalInt();
374            vmfloat r = b->asReal()->evalReal();
375            return successResult(l > r ? l : r);
376        } else {
377            vmint l = a->asInt()->evalInt();
378            vmint r = b->asInt()->evalInt();
379            return successResult(l > r ? l : r);
380        }
381  }  }
382    
383  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
# Line 241  VMFnResult* CoreVMFunction_array_equal:: Line 390  VMFnResult* CoreVMFunction_array_equal::
390          wrnMsg("array_equal(): the two arrays differ in size");          wrnMsg("array_equal(): the two arrays differ in size");
391          return successResult(0); // false          return successResult(0); // false
392      }      }
393      const int n = l->arraySize();      const vmint n = l->arraySize();
394      for (int i = 0; i < n; ++i)      for (vmint i = 0; i < n; ++i)
395          if (l->evalIntElement(i) != r->evalIntElement(i))          if (l->evalIntElement(i) != r->evalIntElement(i))
396              return successResult(0); // false              return successResult(0); // false
397      return successResult(1); // true      return successResult(1); // true
# Line 251  VMFnResult* CoreVMFunction_array_equal:: Line 400  VMFnResult* CoreVMFunction_array_equal::
400  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
401  // built-in script function:  search()  // built-in script function:  search()
402    
403  ExprType_t CoreVMFunction_search::argType(int iArg) const {  ExprType_t CoreVMFunction_search::argType(vmint iArg) const {
404      return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;      return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
405  }  }
406    
407  bool CoreVMFunction_search::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_search::acceptsArgType(vmint iArg, ExprType_t type) const {
408      if (iArg == 0)      if (iArg == 0)
409          return type == INT_ARR_EXPR;          return type == INT_ARR_EXPR;
410      else      else
# Line 264  bool CoreVMFunction_search::acceptsArgTy Line 413  bool CoreVMFunction_search::acceptsArgTy
413    
414  VMFnResult* CoreVMFunction_search::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_search::exec(VMFnArgs* args) {
415      VMIntArrayExpr* a = args->arg(0)->asIntArray();      VMIntArrayExpr* a = args->arg(0)->asIntArray();
416      const int needle = args->arg(1)->asInt()->evalInt();      const vmint needle = args->arg(1)->asInt()->evalInt();
417      const int n = a->arraySize();      const vmint n = a->arraySize();
418      for (int i = 0; i < n; ++i)      for (vmint i = 0; i < n; ++i)
419          if (a->evalIntElement(i) == needle)          if (a->evalIntElement(i) == needle)
420              return successResult(i);              return successResult(i);
421      return successResult(-1); // not found      return successResult(-1); // not found
# Line 275  VMFnResult* CoreVMFunction_search::exec( Line 424  VMFnResult* CoreVMFunction_search::exec(
424  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
425  // built-in script function:  sort()  // built-in script function:  sort()
426    
427  ExprType_t CoreVMFunction_sort::argType(int iArg) const {  ExprType_t CoreVMFunction_sort::argType(vmint iArg) const {
428      return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;      return (iArg == 0) ? INT_ARR_EXPR : INT_EXPR;
429  }  }
430    
431  bool CoreVMFunction_sort::acceptsArgType(int iArg, ExprType_t type) const {  bool CoreVMFunction_sort::acceptsArgType(vmint iArg, ExprType_t type) const {
432      if (iArg == 0)      if (iArg == 0)
433          return type == INT_ARR_EXPR;          return type == INT_ARR_EXPR;
434      else      else
# Line 288  bool CoreVMFunction_sort::acceptsArgType Line 437  bool CoreVMFunction_sort::acceptsArgType
437    
438  struct ArrElemPOD {  struct ArrElemPOD {
439      VMIntArrayExpr* m_array;      VMIntArrayExpr* m_array;
440      int m_index;      vmint m_index;
441  };  };
442    
443  static inline void swap(class ArrElemRef a, class ArrElemRef b);  static inline void swap(class ArrElemRef a, class ArrElemRef b);
# Line 299  public: Line 448  public:
448          m_array = NULL;          m_array = NULL;
449          m_index = 0;          m_index = 0;
450      }      }
451      ArrElemRef(VMIntArrayExpr* a, int index) {      ArrElemRef(VMIntArrayExpr* a, vmint index) {
452          m_array = a;          m_array = a;
453          m_index = index;          m_index = index;
454      }      }
# Line 307  public: Line 456  public:
456          setValue(e.getValue());          setValue(e.getValue());
457          return *this;          return *this;
458      }      }
459      inline ArrElemRef& operator=(int val) {      inline ArrElemRef& operator=(vmint val) {
460          setValue(val);          setValue(val);
461          return *this;          return *this;
462      }      }
# Line 316  public: Line 465  public:
465              return true;              return true;
466          return getValue() == e.getValue();          return getValue() == e.getValue();
467      }      }
468      inline bool operator==(int val) const {      inline bool operator==(vmint val) const {
469          return getValue() == val;          return getValue() == val;
470      }      }
471      inline bool operator!=(const ArrElemRef& e) const {      inline bool operator!=(const ArrElemRef& e) const {
472          return !(operator==(e));          return !(operator==(e));
473      }      }
474      inline bool operator!=(int val) const {      inline bool operator!=(vmint val) const {
475          return !(operator==(val));          return !(operator==(val));
476      }      }
477      inline bool operator<(const ArrElemRef& e) const {      inline bool operator<(const ArrElemRef& e) const {
# Line 330  public: Line 479  public:
479              return false;              return false;
480          return getValue() < e.getValue();          return getValue() < e.getValue();
481      }      }
482      inline bool operator<(int val) const {      inline bool operator<(vmint val) const {
483          return getValue() < val;          return getValue() < val;
484      }      }
485      inline bool operator>(const ArrElemRef& e) const {      inline bool operator>(const ArrElemRef& e) const {
# Line 338  public: Line 487  public:
487              return false;              return false;
488          return getValue() > e.getValue();          return getValue() > e.getValue();
489      }      }
490      inline bool operator>(int val) const {      inline bool operator>(vmint val) const {
491          return getValue() > val;          return getValue() > val;
492      }      }
493      inline bool operator<=(const ArrElemRef& e) const {      inline bool operator<=(const ArrElemRef& e) const {
# Line 346  public: Line 495  public:
495              return true;              return true;
496          return getValue() <= e.getValue();          return getValue() <= e.getValue();
497      }      }
498      inline bool operator<=(int val) const {      inline bool operator<=(vmint val) const {
499          return getValue() <= val;          return getValue() <= val;
500      }      }
501      inline bool operator>=(const ArrElemRef& e) const {      inline bool operator>=(const ArrElemRef& e) const {
# Line 354  public: Line 503  public:
503              return true;              return true;
504          return getValue() >= e.getValue();          return getValue() >= e.getValue();
505      }      }
506      inline bool operator>=(int val) const {      inline bool operator>=(vmint val) const {
507          return getValue() >= val;          return getValue() >= val;
508      }      }
509      inline operator int() const {      inline operator vmint() const {
510          return getValue();          return getValue();
511      }      }
512  protected:  protected:
513      inline int getValue() const {      inline vmint getValue() const {
514          return m_array->evalIntElement(m_index);          return m_array->evalIntElement(m_index);
515      }      }
516      inline void setValue(int value) {      inline void setValue(vmint value) {
517          m_array->assignIntElement(m_index, value);          m_array->assignIntElement(m_index, value);
518      }      }
519    
# Line 377  public: Line 526  public:
526          m_array = NULL;          m_array = NULL;
527          m_index = 0;          m_index = 0;
528      }      }
529      ArrElemPtr(VMIntArrayExpr* a, int index) {      ArrElemPtr(VMIntArrayExpr* a, vmint index) {
530          m_array = a;          m_array = a;
531          m_index = index;          m_index = index;
532      }      }
# Line 387  public: Line 536  public:
536  };  };
537    
538  static inline void swap(ArrElemRef a, ArrElemRef b) {  static inline void swap(ArrElemRef a, ArrElemRef b) {
539      int valueA = a.getValue();      vmint valueA = a.getValue();
540      int valueB = b.getValue();      vmint valueB = b.getValue();
541      a.setValue(valueB);      a.setValue(valueB);
542      b.setValue(valueA);      b.setValue(valueA);
543  }  }
# Line 396  static inline void swap(ArrElemRef a, Ar Line 545  static inline void swap(ArrElemRef a, Ar
545  class ArrExprIter : public ArrElemPOD {  class ArrExprIter : public ArrElemPOD {
546  public:  public:
547      typedef std::random_access_iterator_tag iterator_category;      typedef std::random_access_iterator_tag iterator_category;
548      typedef int value_type;      typedef vmint value_type;
549      typedef ssize_t difference_type;      typedef ssize_t difference_type;
550      typedef ArrElemPtr pointer;      typedef ArrElemPtr pointer;
551      typedef ArrElemRef reference;      typedef ArrElemRef reference;
552    
553      ArrExprIter(VMIntArrayExpr* a, int index) {      ArrExprIter(VMIntArrayExpr* a, vmint index) {
554          m_array = a;          m_array = a;
555          m_index = index;          m_index = index;
556      }      }
# Line 426  public: Line 575  public:
575          --m_index;          --m_index;
576          return it;          return it;
577      }      }
578        inline ArrExprIter& operator+=(difference_type d) {
579            m_index += d;
580            return *this;
581        }
582        inline ArrExprIter& operator-=(difference_type d) {
583            m_index -= d;
584            return *this;
585        }
586      inline bool operator==(const ArrExprIter& other) const {      inline bool operator==(const ArrExprIter& other) const {
587          return m_index == other.m_index;          return m_index == other.m_index;
588      }      }
# Line 462  public: Line 619  public:
619  };  };
620    
621  struct DescArrExprSorter {  struct DescArrExprSorter {
622      inline bool operator()(const int& a, const int& b) const {      inline bool operator()(const vmint& a, const vmint& b) const {
623          return a > b;          return a > b;
624      }      }
625  };  };
# Line 471  VMFnResult* CoreVMFunction_sort::exec(VM Line 628  VMFnResult* CoreVMFunction_sort::exec(VM
628      VMIntArrayExpr* a = args->arg(0)->asIntArray();      VMIntArrayExpr* a = args->arg(0)->asIntArray();
629      bool bAscending =      bool bAscending =
630          (args->argsCount() < 2) ? true : !args->arg(1)->asInt()->evalInt();          (args->argsCount() < 2) ? true : !args->arg(1)->asInt()->evalInt();
631      int n = a->arraySize();      vmint n = a->arraySize();
632      ArrExprIter itBegin(a, 0);      ArrExprIter itBegin(a, 0);
633      ArrExprIter itEnd(a, n);      ArrExprIter itEnd(a, n);
634      if (bAscending) {      if (bAscending) {
# Line 483  VMFnResult* CoreVMFunction_sort::exec(VM Line 640  VMFnResult* CoreVMFunction_sort::exec(VM
640      return successResult();      return successResult();
641  }  }
642    
643    ///////////////////////////////////////////////////////////////////////////
644    // built-in script function:  real_to_int()  and  int()
645    
646    VMFnResult* CoreVMFunction_real_to_int::exec(VMFnArgs* args) {
647        vmfloat f = args->arg(0)->asReal()->evalReal();
648        return successResult(vmint(f));
649    }
650    
651    ///////////////////////////////////////////////////////////////////////////
652    // built-in script function:  int_to_real()  and  real()
653    
654    VMFnResult* CoreVMFunction_int_to_real::exec(VMFnArgs* args) {
655        vmint i = args->arg(0)->asInt()->evalInt();
656        return successResult(i);
657    }
658    
659  } // namespace LinuxSampler  } // namespace LinuxSampler
Legend:
Removed from v.3222  
changed lines
  Added in v.3577
  ViewVC Help
Powered by ViewVC