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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2972 - (show annotations) (download)
Fri Jul 22 14:37:34 2016 UTC (4 years, 5 months ago) by schoenebeck
File size: 6760 byte(s)
* NKSP Fix: "init" event handler was not always executed when a script
  was loaded.
* NKSP built-in wait() script function: abort script execution if
  a negative or zero wait time was passed as argument (since this is
  a common indication of a bug either of the script or even of the
  engine, which could lead to RT instability or even worse).
* Bumped version (2.0.0.svn24).

1 /*
2 * Copyright (c) 2014-2015 Christian Schoenebeck
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 #include "CoreVMFunctions.h"
11
12 #include <iostream>
13 #include <math.h>
14 #include <stdlib.h>
15 #include "tree.h"
16 #include "ScriptVM.h"
17
18 namespace LinuxSampler {
19
20 ///////////////////////////////////////////////////////////////////////////
21 // class VMEmptyResultFunction
22
23 VMFnResult* VMEmptyResultFunction::errorResult() {
24 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
25 return &result;
26 }
27
28 VMFnResult* VMEmptyResultFunction::successResult() {
29 result.flags = STMT_SUCCESS;
30 return &result;
31 }
32
33 ///////////////////////////////////////////////////////////////////////////
34 // class VMIntResultFunction
35
36 VMFnResult* VMIntResultFunction::errorResult(int i) {
37 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
38 result.value = i;
39 return &result;
40 }
41
42 VMFnResult* VMIntResultFunction::successResult(int i) {
43 result.flags = STMT_SUCCESS;
44 result.value = i;
45 return &result;
46 }
47
48 ///////////////////////////////////////////////////////////////////////////
49 // class VMStringResultFunction
50
51 VMFnResult* VMStringResultFunction::errorResult(const String& s) {
52 result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
53 result.value = s;
54 return &result;
55 }
56
57 VMFnResult* VMStringResultFunction::successResult(const String& s) {
58 result.flags = STMT_SUCCESS;
59 result.value = s;
60 return &result;
61 }
62
63 ///////////////////////////////////////////////////////////////////////////
64 // built-in script function: message()
65
66 bool CoreVMFunction_message::acceptsArgType(int iArg, ExprType_t type) const {
67 return type == INT_EXPR || type == STRING_EXPR;
68 }
69
70 VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {
71 if (!args->argsCount()) return errorResult();
72
73 VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));
74 if (strExpr) {
75 std::cout << "[ScriptVM] " << strExpr->evalStr() << "\n";
76 return successResult();
77 }
78
79 VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
80 if (intExpr) {
81 std::cout << "[ScriptVM] " << intExpr->evalInt() << "\n";
82 return successResult();
83 }
84
85 return errorResult();
86 }
87
88 ///////////////////////////////////////////////////////////////////////////
89 // built-in script function: exit()
90
91 VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
92 this->result.flags = STMT_ABORT_SIGNALLED;
93 return &result;
94 }
95
96 ///////////////////////////////////////////////////////////////////////////
97 // built-in script function: wait()
98
99 VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {
100 ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
101 VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));
102 int us = expr->evalInt();
103 if (us < 0) {
104 wrnMsg("wait(): argument may not be negative! Aborting script!");
105 this->result.flags = STMT_ABORT_SIGNALLED;
106 } else if (us == 0) {
107 wrnMsg("wait(): argument may not be zero! Aborting script!");
108 this->result.flags = STMT_ABORT_SIGNALLED;
109 } else {
110 ctx->suspendMicroseconds = us;
111 this->result.flags = STMT_SUSPEND_SIGNALLED;
112 }
113 return &result;
114 }
115
116 ///////////////////////////////////////////////////////////////////////////
117 // built-in script function: abs()
118
119 bool CoreVMFunction_abs::acceptsArgType(int iArg, ExprType_t type) const {
120 return type == INT_EXPR;
121 }
122
123 VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {
124 return successResult( ::abs(args->arg(0)->asInt()->evalInt()) );
125 }
126
127 ///////////////////////////////////////////////////////////////////////////
128 // built-in script function: random()
129
130 bool CoreVMFunction_random::acceptsArgType(int iArg, ExprType_t type) const {
131 return type == INT_EXPR;
132 }
133
134 VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {
135 int iMin = args->arg(0)->asInt()->evalInt();
136 int iMax = args->arg(1)->asInt()->evalInt();
137 float f = float(::rand()) / float(RAND_MAX);
138 return successResult(
139 iMin + roundf( f * float(iMax - iMin) )
140 );
141 }
142
143 ///////////////////////////////////////////////////////////////////////////
144 // built-in script function: num_elements()
145
146 bool CoreVMFunction_num_elements::acceptsArgType(int iArg, ExprType_t type) const {
147 return type == INT_ARR_EXPR;
148 }
149
150 VMFnResult* CoreVMFunction_num_elements::exec(VMFnArgs* args) {
151 return successResult( args->arg(0)->asIntArray()->arraySize() );
152 }
153
154 ///////////////////////////////////////////////////////////////////////////
155 // built-in script function: inc()
156
157 VMFnResult* CoreVMFunction_inc::exec(VMFnArgs* args) {
158 VMExpr* arg = args->arg(0);
159 VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
160 VMVariable* out = dynamic_cast<VMVariable*>(arg);
161 if (!in || !out) successResult(0);
162 int i = in->evalInt() + 1;
163 IntLiteral tmp(i);
164 out->assignExpr(&tmp);
165 return successResult(i);
166 }
167
168 ///////////////////////////////////////////////////////////////////////////
169 // built-in script function: dec()
170
171 VMFnResult* CoreVMFunction_dec::exec(VMFnArgs* args) {
172 VMExpr* arg = args->arg(0);
173 VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
174 VMVariable* out = dynamic_cast<VMVariable*>(arg);
175 if (!in || !out) successResult(0);
176 int i = in->evalInt() - 1;
177 IntLiteral tmp(i);
178 out->assignExpr(&tmp);
179 return successResult(i);
180 }
181
182 ///////////////////////////////////////////////////////////////////////////
183 // built-in script function: sh_left()
184
185 VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
186 int i = args->arg(0)->asInt()->evalInt();
187 int n = args->arg(1)->asInt()->evalInt();
188 return successResult(i << n);
189 }
190
191 ///////////////////////////////////////////////////////////////////////////
192 // built-in script function: sh_right()
193
194 VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
195 int i = args->arg(0)->asInt()->evalInt();
196 int n = args->arg(1)->asInt()->evalInt();
197 return successResult(i >> n);
198 }
199
200 ///////////////////////////////////////////////////////////////////////////
201 // built-in script function: min()
202
203 VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
204 int l = args->arg(0)->asInt()->evalInt();
205 int r = args->arg(1)->asInt()->evalInt();
206 return successResult(l < r ? l : r);
207 }
208
209 ///////////////////////////////////////////////////////////////////////////
210 // built-in script function: max()
211
212 VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
213 int l = args->arg(0)->asInt()->evalInt();
214 int r = args->arg(1)->asInt()->evalInt();
215 return successResult(l > r ? l : r);
216 }
217
218 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC