/[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 3590 by schoenebeck, Mon Sep 2 09:03:31 2019 UTC revision 3747 by schoenebeck, Sun Feb 16 11:31:46 2020 UTC
# Line 1  Line 1 
1  /*  /*
2   * Copyright (c) 2014-2019 Christian Schoenebeck   * Copyright (c) 2014-2020 Christian Schoenebeck
3   *   *
4   * http://www.linuxsampler.org   * http://www.linuxsampler.org
5   *   *
# Line 27  inline bool _fEqualX(vmfloat a, vmfloat Line 27  inline bool _fEqualX(vmfloat a, vmfloat
27  }  }
28    
29  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
30    // class VMIntResult
31    
32    VMIntResult::VMIntResult() :
33        flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR),
34        unitBaseType(VM_NO_UNIT)
35    {
36    }
37    
38    ///////////////////////////////////////////////////////////////////////////
39    // class VMRealResult
40    
41    VMRealResult::VMRealResult() :
42        flags(STMT_SUCCESS), value(0), unitPrefixFactor(VM_NO_FACTOR),
43        unitBaseType(VM_NO_UNIT)
44    {
45    
46    }
47    
48    ///////////////////////////////////////////////////////////////////////////
49  // class VMEmptyResultFunction  // class VMEmptyResultFunction
50    
51    void VMEmptyResultFunction::bindResult(VMFnResult* res) {
52        result = dynamic_cast<VMEmptyResult*>(res);
53    }
54    
55    VMFnResult* VMEmptyResultFunction::boundResult() const {
56        return result;
57    }
58    
59  VMFnResult* VMEmptyResultFunction::errorResult() {  VMFnResult* VMEmptyResultFunction::errorResult() {
60      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
61      return &result;      return result;
62  }  }
63    
64  VMFnResult* VMEmptyResultFunction::successResult() {  VMFnResult* VMEmptyResultFunction::successResult() {
65      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
66      return &result;      return result;
67  }  }
68    
69  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
70  // class VMIntResultFunction  // class VMIntResultFunction
71    
72    void VMIntResultFunction::bindResult(VMFnResult* res) {
73        result = dynamic_cast<VMIntResult*>(res);
74    }
75    
76    VMFnResult* VMIntResultFunction::boundResult() const {
77        return result;
78    }
79    
80  VMFnResult* VMIntResultFunction::errorResult(vmint i) {  VMFnResult* VMIntResultFunction::errorResult(vmint i) {
81      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
82      result.value = i;      result->value = i;
83      result.unitPrefixFactor = VM_NO_FACTOR;      result->unitPrefixFactor = VM_NO_FACTOR;
84      return &result;      result->unitBaseType = VM_NO_UNIT;
85        return result;
86  }  }
87    
88  VMFnResult* VMIntResultFunction::successResult(vmint i) {  VMFnResult* VMIntResultFunction::successResult(vmint i) {
89      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
90      result.value = i;      result->value = i;
91      result.unitPrefixFactor = VM_NO_FACTOR;      result->unitPrefixFactor = VM_NO_FACTOR;
92      return &result;      result->unitBaseType = VM_NO_UNIT;
93        return result;
94  }  }
95    
96  VMFnResult* VMIntResultFunction::errorResult(VMIntFnResDef res) {  VMFnResult* VMIntResultFunction::errorResult(VMIntFnResDef res) {
97      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
98      result.value = res.value;      result->value = res.value;
99      result.unitPrefixFactor = res.unitFactor;      result->unitPrefixFactor = res.unitFactor;
100      return &result;      result->unitBaseType = VM_NO_UNIT;
101        return result;
102  }  }
103    
104  VMFnResult* VMIntResultFunction::successResult(VMIntFnResDef res) {  VMFnResult* VMIntResultFunction::successResult(VMIntFnResDef res) {
105      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
106      result.value = res.value;      result->value = res.value;
107      result.unitPrefixFactor = res.unitFactor;      result->unitPrefixFactor = res.unitFactor;
108      return &result;      result->unitBaseType = VM_NO_UNIT;
109        return result;
110  }  }
111    
112  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
113  // class VMRealResultFunction  // class VMRealResultFunction
114    
115    void VMRealResultFunction::bindResult(VMFnResult* res) {
116        result = dynamic_cast<VMRealResult*>(res);
117    }
118    
119    VMFnResult* VMRealResultFunction::boundResult() const {
120        return result;
121    }
122    
123  VMFnResult* VMRealResultFunction::errorResult(vmfloat f) {  VMFnResult* VMRealResultFunction::errorResult(vmfloat f) {
124      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
125      result.value = f;      result->value = f;
126      result.unitPrefixFactor = VM_NO_FACTOR;      result->unitPrefixFactor = VM_NO_FACTOR;
127      return &result;      result->unitBaseType = VM_NO_UNIT;
128        return result;
129  }  }
130    
131  VMFnResult* VMRealResultFunction::errorResult(VMRealFnResDef res) {  VMFnResult* VMRealResultFunction::errorResult(VMRealFnResDef res) {
132      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
133      result.value = res.value;      result->value = res.value;
134      result.unitPrefixFactor = res.unitFactor;      result->unitPrefixFactor = res.unitFactor;
135      return &result;      result->unitBaseType = VM_NO_UNIT;
136        return result;
137  }  }
138    
139  VMFnResult* VMRealResultFunction::successResult(vmfloat f) {  VMFnResult* VMRealResultFunction::successResult(vmfloat f) {
140      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
141      result.value = f;      result->value = f;
142      result.unitPrefixFactor = VM_NO_FACTOR;      result->unitPrefixFactor = VM_NO_FACTOR;
143      return &result;      result->unitBaseType = VM_NO_UNIT;
144        return result;
145  }  }
146    
147  VMFnResult* VMRealResultFunction::successResult(VMRealFnResDef res) {  VMFnResult* VMRealResultFunction::successResult(VMRealFnResDef res) {
148      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
149      result.value = res.value;      result->value = res.value;
150      result.unitPrefixFactor = res.unitFactor;      result->unitPrefixFactor = res.unitFactor;
151      return &result;      result->unitBaseType = VM_NO_UNIT;
152        return result;
153  }  }
154    
155  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
156  // class VMStringResultFunction  // class VMStringResultFunction
157    
158    void VMStringResultFunction::bindResult(VMFnResult* res) {
159        result = dynamic_cast<VMStringResult*>(res);
160    }
161    
162    VMFnResult* VMStringResultFunction::boundResult() const {
163        return result;
164    }
165    
166  VMFnResult* VMStringResultFunction::errorResult(const String& s) {  VMFnResult* VMStringResultFunction::errorResult(const String& s) {
167      result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      result->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
168      result.value = s;      result->value = s;
169      return &result;      return result;
170  }  }
171    
172  VMFnResult* VMStringResultFunction::successResult(const String& s) {  VMFnResult* VMStringResultFunction::successResult(const String& s) {
173      result.flags = STMT_SUCCESS;      result->flags = STMT_SUCCESS;
174      result.value = s;      result->value = s;
175      return &result;      return result;
176  }  }
177    
178  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
179  // class VMNumberResultFunction  // class VMNumberResultFunction
180    
181    VMFnResult* VMNumberResultFunction::allocResult(VMFnArgs* args) {
182        ExprType_t type = returnType(args);
183        if (type == INT_EXPR)
184            return new VMIntResult();
185        if (type == REAL_EXPR)
186            return new VMRealResult();
187        assert(false);
188        return NULL; // just to avoid compiler error, we actually never get here
189    }
190    
191    VMFnResult* VMNumberResultFunction::boundResult() const {
192        if (intResult) return intResult;
193        return realResult;
194    }
195    
196    void VMNumberResultFunction::bindResult(VMFnResult* res) {
197        intResult = dynamic_cast<VMIntResult*>(res);
198        if (intResult) {
199            realResult = NULL;
200            return;
201        }
202        realResult = dynamic_cast<VMRealResult*>(res);
203    }
204    
205  VMFnResult* VMNumberResultFunction::errorResult(vmint i) {  VMFnResult* VMNumberResultFunction::errorResult(vmint i) {
206      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      intResult->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
207      intResult.value = i;      intResult->value = i;
208      intResult.unitPrefixFactor = VM_NO_FACTOR;      intResult->unitPrefixFactor = VM_NO_FACTOR;
209      return &intResult;      intResult->unitBaseType = VM_NO_UNIT;
210        return intResult;
211  }  }
212    
213  VMFnResult* VMNumberResultFunction::errorResult(vmfloat f) {  VMFnResult* VMNumberResultFunction::errorResult(vmfloat f) {
214      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      realResult->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
215      realResult.value = f;      realResult->value = f;
216      realResult.unitPrefixFactor = VM_NO_FACTOR;      realResult->unitPrefixFactor = VM_NO_FACTOR;
217      return &realResult;      intResult->unitBaseType = VM_NO_UNIT;
218        return realResult;
219  }  }
220    
221  VMFnResult* VMNumberResultFunction::successResult(vmint i) {  VMFnResult* VMNumberResultFunction::successResult(vmint i) {
222      intResult.flags = STMT_SUCCESS;      intResult->flags = STMT_SUCCESS;
223      intResult.value = i;      intResult->value = i;
224      intResult.unitPrefixFactor = VM_NO_FACTOR;      intResult->unitPrefixFactor = VM_NO_FACTOR;
225      return &intResult;      intResult->unitBaseType = VM_NO_UNIT;
226        return intResult;
227  }  }
228    
229  VMFnResult* VMNumberResultFunction::successResult(vmfloat f) {  VMFnResult* VMNumberResultFunction::successResult(vmfloat f) {
230      realResult.flags = STMT_SUCCESS;      realResult->flags = STMT_SUCCESS;
231      realResult.value = f;      realResult->value = f;
232      realResult.unitPrefixFactor = VM_NO_FACTOR;      realResult->unitPrefixFactor = VM_NO_FACTOR;
233      return &realResult;      realResult->unitBaseType = VM_NO_UNIT;
234        return realResult;
235  }  }
236    
237  VMFnResult* VMNumberResultFunction::errorIntResult(VMIntFnResDef res) {  VMFnResult* VMNumberResultFunction::errorIntResult(VMIntFnResDef res) {
238      intResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      intResult->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
239      intResult.value = res.value;      intResult->value = res.value;
240      intResult.unitPrefixFactor = res.unitFactor;      intResult->unitPrefixFactor = res.unitFactor;
241      return &intResult;      intResult->unitBaseType = VM_NO_UNIT;
242        return intResult;
243  }  }
244    
245  VMFnResult* VMNumberResultFunction::errorRealResult(VMRealFnResDef res) {  VMFnResult* VMNumberResultFunction::errorRealResult(VMRealFnResDef res) {
246      realResult.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);      realResult->flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
247      realResult.value = res.value;      realResult->value = res.value;
248      realResult.unitPrefixFactor = res.unitFactor;      realResult->unitPrefixFactor = res.unitFactor;
249      return &realResult;      realResult->unitBaseType = VM_NO_UNIT;
250        return realResult;
251  }  }
252    
253  VMFnResult* VMNumberResultFunction::successIntResult(VMIntFnResDef res) {  VMFnResult* VMNumberResultFunction::successIntResult(VMIntFnResDef res) {
254      intResult.flags = STMT_SUCCESS;      intResult->flags = STMT_SUCCESS;
255      intResult.value = res.value;      intResult->value = res.value;
256      intResult.unitPrefixFactor = res.unitFactor;      intResult->unitPrefixFactor = res.unitFactor;
257      return &intResult;      intResult->unitBaseType = VM_NO_UNIT;
258        return intResult;
259  }  }
260    
261  VMFnResult* VMNumberResultFunction::successRealResult(VMRealFnResDef res) {  VMFnResult* VMNumberResultFunction::successRealResult(VMRealFnResDef res) {
262      realResult.flags = STMT_SUCCESS;      realResult->flags = STMT_SUCCESS;
263      realResult.value = res.value;      realResult->value = res.value;
264      realResult.unitPrefixFactor = res.unitFactor;      realResult->unitPrefixFactor = res.unitFactor;
265      return &realResult;      realResult->unitBaseType = VM_NO_UNIT;
266        return realResult;
267  }  }
268    
269  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
# Line 201  VMFnResult* CoreVMFunction_message::exec Line 292  VMFnResult* CoreVMFunction_message::exec
292    
293      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));      VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
294      if (intExpr) {      if (intExpr) {
295          printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());          printf("[ScriptVM %.3f] %" PRId64 "\n", usecs/1000000.f, (int64_t)intExpr->evalInt());
296          return successResult();          return successResult();
297      }      }
298    
# Line 235  bool CoreVMFunction_exit::acceptsArgFina Line 326  bool CoreVMFunction_exit::acceptsArgFina
326  }  }
327    
328  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {  VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
329      this->result.flags = STMT_ABORT_SIGNALLED;      this->result->flags = STMT_ABORT_SIGNALLED;
330      if (vm->isExitResultEnabled() && args->argsCount()) {      if (vm->isExitResultEnabled() && args->argsCount()) {
331          ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());          ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
332          switch (args->arg(0)->exprType()) {          switch (args->arg(0)->exprType()) {
# Line 271  VMFnResult* CoreVMFunction_exit::exec(VM Line 362  VMFnResult* CoreVMFunction_exit::exec(VM
362                  ; // noop - just to shut up the compiler                  ; // noop - just to shut up the compiler
363          }          }
364      }      }
365      return &result;      return result;
366  }  }
367    
368  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
# Line 295  VMFnResult* CoreVMFunction_wait::exec(VM Line 386  VMFnResult* CoreVMFunction_wait::exec(VM
386      StdUnit_t unit = expr->unitType();      StdUnit_t unit = expr->unitType();
387      vmint us = (unit) ? expr->evalCastInt(VM_MICRO) : expr->evalCastInt();      vmint us = (unit) ? expr->evalCastInt(VM_MICRO) : expr->evalCastInt();
388      if (us < 0) {      if (us < 0) {
389          wrnMsg("wait(): argument may not be negative! Aborting script!");          wrnMsg("wait(): argument may not be negative! Aborting handler!");
390          this->result.flags = STMT_ABORT_SIGNALLED;          this->result->flags = STMT_ABORT_SIGNALLED;
391      } else if (us == 0) {      } else if (us == 0) {
392          wrnMsg("wait(): argument may not be zero! Aborting script!");          wrnMsg("wait(): argument may not be zero! Aborting handler!");
393          this->result.flags = STMT_ABORT_SIGNALLED;          this->result->flags = STMT_ABORT_SIGNALLED;
394      } else {      } else {
395          ctx->suspendMicroseconds = us;          ctx->suspendMicroseconds = us;
396          this->result.flags = STMT_SUSPEND_SIGNALLED;          this->result->flags = STMT_SUSPEND_SIGNALLED;
397      }      }
398      return &result;      return result;
399  }  }
400    
401  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
# Line 331  VMFnResult* CoreVMFunction_abs::exec(VMF Line 422  VMFnResult* CoreVMFunction_abs::exec(VMF
422      if (arg->exprType() == REAL_EXPR) {      if (arg->exprType() == REAL_EXPR) {
423          VMRealExpr* expr = arg->asReal();          VMRealExpr* expr = arg->asReal();
424          return successRealResult({          return successRealResult({
425              .value = ::fabs(expr->evalReal()),              .value = static_cast<vmfloat>(::fabs(expr->evalReal())),
426              .unitFactor = expr->unitFactor()              .unitFactor = expr->unitFactor()
427          });          });
428      } else {      } else {
429          VMIntExpr* expr = arg->asInt();          VMIntExpr* expr = arg->asInt();
430          return successIntResult({          return successIntResult({
431              .value = ::abs(expr->evalInt()),              .value = std::abs(expr->evalInt()),
432              .unitFactor = expr->unitFactor()              .unitFactor = expr->unitFactor()
433          });          });
434      }      }
# Line 626  VMFnResult* CoreVMFunction_sh_right::exe Line 717  VMFnResult* CoreVMFunction_sh_right::exe
717  }  }
718    
719  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
720    // built-in script function:  msb()
721    
722    VMFnResult* CoreVMFunction_msb::exec(VMFnArgs* args) {
723        vmint i = args->arg(0)->asInt()->evalInt();
724        return successResult((i >> 7) & 127);
725    }
726    
727    ///////////////////////////////////////////////////////////////////////////
728    // built-in script function:  lsb()
729    
730    VMFnResult* CoreVMFunction_lsb::exec(VMFnArgs* args) {
731        vmint i = args->arg(0)->asInt()->evalInt();
732        return successResult(i & 127);
733    }
734    
735    ///////////////////////////////////////////////////////////////////////////
736  // built-in script function:  min()  // built-in script function:  min()
737    
738  ExprType_t CoreVMFunction_min::returnType(VMFnArgs* args) {  ExprType_t CoreVMFunction_min::returnType(VMFnArgs* args) {
# Line 1038  template<class T_array, // T_array is ei Line 1145  template<class T_array, // T_array is ei
1145           class T_accessor> // T_accessor is either IntArrayAccessor or RealArrayAccessor           class T_accessor> // T_accessor is either IntArrayAccessor or RealArrayAccessor
1146  class ArrElemRef : protected ArrElemPOD<T_array> {  class ArrElemRef : protected ArrElemPOD<T_array> {
1147  public:  public:
1148      typedef ScalarNmbrVal<T_value> ScalarNmbrVal;      typedef ::LinuxSampler::ScalarNmbrVal<T_value> ScalarNmbrVal; // GCC 8.x requires this very detailed form of typedef (that is ::LinuxSampler:: as prefix), IMO a GCC bug
1149    
1150      inline ArrElemRef(T_array* a, vmint index) {      inline ArrElemRef(T_array* a, vmint index) {
1151          this->m_array = a;          this->m_array = a;
# Line 1131  class ArrExprIter : public ArrElemPOD<T_ Line 1238  class ArrExprIter : public ArrElemPOD<T_
1238  public:  public:
1239      typedef std::random_access_iterator_tag iterator_category;      typedef std::random_access_iterator_tag iterator_category;
1240      typedef ssize_t difference_type;      typedef ssize_t difference_type;
1241      typedef ArrElemRef<T_array, T_value, T_accessor> ArrElemRef;      typedef ::LinuxSampler::ArrElemRef<T_array, T_value, T_accessor> ArrElemRef; // GCC 8.x requires this very detailed form of typedef (that is ::LinuxSampler:: as prefix), IMO a GCC bug
1242      typedef ArrElemRef reference; // type used by STL for access by reference      typedef ArrElemRef reference; // type used by STL for access by reference
1243      typedef void pointer; // type used by STL for -> operator result, we don't use that operator at all so just void it      typedef void pointer; // type used by STL for -> operator result, we don't use that operator at all so just void it
1244      typedef ScalarNmbrVal<T_value> value_type; // type used by STL for temporary values      typedef ScalarNmbrVal<T_value> value_type; // type used by STL for temporary values
# Line 1212  typedef ArrExprIter<VMIntArrayExpr,vmint Line 1319  typedef ArrExprIter<VMIntArrayExpr,vmint
1319  typedef ArrExprIter<VMRealArrayExpr,vmfloat,RealArrayAccessor> RealArrExprIter;  typedef ArrExprIter<VMRealArrayExpr,vmfloat,RealArrayAccessor> RealArrExprIter;
1320    
1321  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1322  static inline void swap(IntArrExprIter::ArrElemRef a,  inline void swap(IntArrExprIter::ArrElemRef a,
1323                          IntArrExprIter::ArrElemRef b)                   IntArrExprIter::ArrElemRef b)
1324  {  {
1325      vmint valueA = a.getPrimValue();      vmint valueA = a.getPrimValue();
1326      vmint valueB = b.getPrimValue();      vmint valueB = b.getPrimValue();
# Line 1226  static inline void swap(IntArrExprIter:: Line 1333  static inline void swap(IntArrExprIter::
1333  }  }
1334    
1335  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions  // intentionally not a template function to avoid potential clashes with other (i.e. system's) swap() functions
1336  static inline void swap(RealArrExprIter::ArrElemRef a,  inline void swap(RealArrExprIter::ArrElemRef a,
1337                          RealArrExprIter::ArrElemRef b)                   RealArrExprIter::ArrElemRef b)
1338  {  {
1339      vmfloat valueA = a.getPrimValue();      vmfloat valueA = a.getPrimValue();
1340      vmfloat valueB = b.getPrimValue();      vmfloat valueB = b.getPrimValue();
# Line 1546  VMFnResult* CoreVMFunction_pow::exec(VMF Line 1653  VMFnResult* CoreVMFunction_pow::exec(VMF
1653          });          });
1654      } else {      } else {
1655          return successResult({          return successResult({
1656              .value = ::pow(a,b),              .value = static_cast<vmfloat>(::pow(a,b)),
1657              .unitFactor = arg0->unitFactor()              .unitFactor = arg0->unitFactor()
1658          });          });
1659      }      }
Legend:
Removed from v.3590  
changed lines
  Added in v.3747
  ViewVC Help
Powered by ViewVC