/[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 3557 by schoenebeck, Sun Aug 18 00:06:04 2019 UTC revision 3577 by schoenebeck, Wed Aug 28 15:23:23 2019 UTC
# Line 48  VMFnResult* VMIntResultFunction::success Line 48  VMFnResult* VMIntResultFunction::success
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 63  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(vmint 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) {
# Line 80  VMFnResult* CoreVMFunction_message::exec Line 122  VMFnResult* CoreVMFunction_message::exec
122          return successResult();          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();
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          printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());          printf("[ScriptVM %.3f] %lld\n", usecs/1000000.f, (int64_t)intExpr->evalInt());
# Line 98  vmint CoreVMFunction_exit::maxAllowedArg Line 146  vmint CoreVMFunction_exit::maxAllowedArg
146    
147  bool CoreVMFunction_exit::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_exit::acceptsArgType(vmint iArg, ExprType_t type) const {
148      if (!vm->isExitResultEnabled()) return false;      if (!vm->isExitResultEnabled()) return false;
149      return type == INT_EXPR || type == STRING_EXPR;      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) {
# Line 110  VMFnResult* CoreVMFunction_exit::exec(VM Line 158  VMFnResult* CoreVMFunction_exit::exec(VM
158                  ctx->exitRes.intLiteral.value = args->arg(0)->asInt()->evalInt();                  ctx->exitRes.intLiteral.value = args->arg(0)->asInt()->evalInt();
159                  ctx->exitRes.value = &ctx->exitRes.intLiteral;                  ctx->exitRes.value = &ctx->exitRes.intLiteral;
160                  break;                  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:              case STRING_EXPR:
166                  ctx->exitRes.stringLiteral.value = args->arg(0)->asString()->evalStr();                  ctx->exitRes.stringLiteral.value = args->arg(0)->asString()->evalStr();
167                  ctx->exitRes.value = &ctx->exitRes.stringLiteral;                  ctx->exitRes.value = &ctx->exitRes.stringLiteral;
# Line 124  VMFnResult* CoreVMFunction_exit::exec(VM Line 176  VMFnResult* CoreVMFunction_exit::exec(VM
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      vmint 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 144  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    ExprType_t CoreVMFunction_abs::returnType(VMFnArgs* args) {
212        return args->arg(0)->exprType();
213    }
214    
215  bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {  bool CoreVMFunction_abs::acceptsArgType(vmint iArg, ExprType_t type) const {
216      return type == INT_EXPR;      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  ///////////////////////////////////////////////////////////////////////////  ///////////////////////////////////////////////////////////////////////////
# Line 243  VMFnResult* CoreVMFunction_sh_right::exe Line 315  VMFnResult* CoreVMFunction_sh_right::exe
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      vmint l = args->arg(0)->asInt()->evalInt();      VMExpr* a = args->arg(0);
329      vmint 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      vmint l = args->arg(0)->asInt()->evalInt();      VMExpr* a = args->arg(0);
363      vmint 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 518  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.3557  
changed lines
  Added in v.3577
  ViewVC Help
Powered by ViewVC