src/scriptvm/CoreVMFunctions.cpp

/*
 * Copyright (c) 2014-2015 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

#include "CoreVMFunctions.h"

#include <iostream>
#include <math.h>
#include <stdlib.h>
#include "tree.h"
#include "ScriptVM.h"

namespace LinuxSampler {

///////////////////////////////////////////////////////////////////////////
// class VMEmptyResultFunction

VMFnResult* VMEmptyResultFunction::errorResult() {
    result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
    return &result;
}

VMFnResult* VMEmptyResultFunction::successResult() {
    result.flags = STMT_SUCCESS;
    return &result;
}

///////////////////////////////////////////////////////////////////////////
// class VMIntResultFunction

VMFnResult* VMIntResultFunction::errorResult(int i) {
    result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
    result.value = i;
    return &result;
}

VMFnResult* VMIntResultFunction::successResult(int i) {
    result.flags = STMT_SUCCESS;
    result.value = i;
    return &result;
}

///////////////////////////////////////////////////////////////////////////
// class VMStringResultFunction

VMFnResult* VMStringResultFunction::errorResult(const String& s) {
    result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED | STMT_ERROR_OCCURRED);
    result.value = s;
    return &result;
}

VMFnResult* VMStringResultFunction::successResult(const String& s) {
    result.flags = STMT_SUCCESS;
    result.value = s;
    return &result;
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  message()

bool CoreVMFunction_message::acceptsArgType(int iArg, ExprType_t type) const {
    return type == INT_EXPR || type == STRING_EXPR;
}

VMFnResult* CoreVMFunction_message::exec(VMFnArgs* args) {
    if (!args->argsCount()) return errorResult();

    VMStringExpr* strExpr = dynamic_cast<VMStringExpr*>(args->arg(0));
    if (strExpr) {
        std::cout << "[ScriptVM] " << strExpr->evalStr() << "\n";
        return successResult();
    }

    VMIntExpr* intExpr = dynamic_cast<VMIntExpr*>(args->arg(0));
    if (intExpr) {
        std::cout << "[ScriptVM] " << intExpr->evalInt() << "\n";
        return successResult();
    }

    return errorResult();
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  exit()

VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
    this->result.flags = STMT_ABORT_SIGNALLED;
    return &result;
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  wait()

VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {
    ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
    VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));
    int us = expr->evalInt();
    if (us < 0) {
        wrnMsg("wait(): argument may not be negative! Aborting script!");
        this->result.flags = STMT_ABORT_SIGNALLED;
    } else if (us == 0) {
        wrnMsg("wait(): argument may not be zero! Aborting script!");
        this->result.flags = STMT_ABORT_SIGNALLED;
    } else {
        ctx->suspendMicroseconds = us;
        this->result.flags = STMT_SUSPEND_SIGNALLED;
    }
    return &result;
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  abs()

bool CoreVMFunction_abs::acceptsArgType(int iArg, ExprType_t type) const {
    return type == INT_EXPR;
}

VMFnResult* CoreVMFunction_abs::exec(VMFnArgs* args) {
    return successResult( ::abs(args->arg(0)->asInt()->evalInt()) );
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  random()

bool CoreVMFunction_random::acceptsArgType(int iArg, ExprType_t type) const {
    return type == INT_EXPR;
}

VMFnResult* CoreVMFunction_random::exec(VMFnArgs* args) {
    int iMin = args->arg(0)->asInt()->evalInt();
    int iMax = args->arg(1)->asInt()->evalInt();
    float f = float(::rand()) / float(RAND_MAX);
    return successResult(
        iMin + roundf( f * float(iMax - iMin) )
    );
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  num_elements()

bool CoreVMFunction_num_elements::acceptsArgType(int iArg, ExprType_t type) const {
    return type == INT_ARR_EXPR;
}

VMFnResult* CoreVMFunction_num_elements::exec(VMFnArgs* args) {
    return successResult( args->arg(0)->asIntArray()->arraySize() );
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  inc()

VMFnResult* CoreVMFunction_inc::exec(VMFnArgs* args) {
    VMExpr* arg = args->arg(0);
    VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
    VMVariable* out = dynamic_cast<VMVariable*>(arg);
    if (!in || !out) successResult(0);
    int i = in->evalInt() + 1;
    IntLiteral tmp(i);
    out->assignExpr(&tmp);
    return successResult(i);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  dec()

VMFnResult* CoreVMFunction_dec::exec(VMFnArgs* args) {
    VMExpr* arg = args->arg(0);
    VMIntExpr* in = dynamic_cast<VMIntExpr*>(arg);
    VMVariable* out = dynamic_cast<VMVariable*>(arg);
    if (!in || !out) successResult(0);
    int i = in->evalInt() - 1;
    IntLiteral tmp(i);
    out->assignExpr(&tmp);
    return successResult(i);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  in_range()

VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {
    int i  = args->arg(0)->asInt()->evalInt();
    int lo = args->arg(1)->asInt()->evalInt();
    int hi = args->arg(2)->asInt()->evalInt();
    if (lo > hi) { // swap lo and hi
        int tmp = lo;
        lo = hi;
        hi = tmp;
    }
    return successResult(i >= lo && i <= hi);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  sh_left()

VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
    int i = args->arg(0)->asInt()->evalInt();
    int n = args->arg(1)->asInt()->evalInt();
    return successResult(i << n);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  sh_right()

VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
    int i = args->arg(0)->asInt()->evalInt();
    int n = args->arg(1)->asInt()->evalInt();
    return successResult(i >> n);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  min()

VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
    int l = args->arg(0)->asInt()->evalInt();
    int r = args->arg(1)->asInt()->evalInt();
    return successResult(l < r ? l : r);
}

///////////////////////////////////////////////////////////////////////////
// built-in script function:  max()

VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
    int l = args->arg(0)->asInt()->evalInt();
    int r = args->arg(1)->asInt()->evalInt();
    return successResult(l > r ? l : r);
}

} // namespace LinuxSampler
1	schoenebeck	2581	/*
2	schoenebeck	2727	* Copyright (c) 2014-2015 Christian Schoenebeck
3	schoenebeck	2581	*
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	schoenebeck	2619	#include <math.h>
14			#include <stdlib.h>
15	schoenebeck	2581	#include "tree.h"
16			#include "ScriptVM.h"
17
18			namespace LinuxSampler {
19
20	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
21			// class VMEmptyResultFunction
22
23	schoenebeck	2581	VMFnResult* VMEmptyResultFunction::errorResult() {
24			result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED \| STMT_ERROR_OCCURRED);
25			return &result;
26			}
27
28	schoenebeck	2598	VMFnResult* VMEmptyResultFunction::successResult() {
29			result.flags = STMT_SUCCESS;
30			return &result;
31	schoenebeck	2596	}
32
33	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
34			// class VMIntResultFunction
35
36	schoenebeck	2598	VMFnResult* VMIntResultFunction::errorResult(int i) {
37			result.flags = StmtFlags_t(STMT_ABORT_SIGNALLED \| STMT_ERROR_OCCURRED);
38			result.value = i;
39			return &result;
40	schoenebeck	2596	}
41
42	schoenebeck	2598	VMFnResult* VMIntResultFunction::successResult(int i) {
43	schoenebeck	2581	result.flags = STMT_SUCCESS;
44	schoenebeck	2598	result.value = i;
45	schoenebeck	2581	return &result;
46			}
47
48	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
49			// class VMStringResultFunction
50
51	schoenebeck	2581	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	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
64			// built-in script function: message()
65
66	schoenebeck	2581	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	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
89			// built-in script function: exit()
90
91	schoenebeck	2581	VMFnResult* CoreVMFunction_exit::exec(VMFnArgs* args) {
92			this->result.flags = STMT_ABORT_SIGNALLED;
93			return &result;
94			}
95
96	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
97			// built-in script function: wait()
98
99	schoenebeck	2581	VMFnResult* CoreVMFunction_wait::exec(VMFnArgs* args) {
100			ExecContext* ctx = dynamic_cast<ExecContext*>(vm->currentVMExecContext());
101			VMIntExpr* expr = dynamic_cast<VMIntExpr*>(args->arg(0));
102	schoenebeck	2972	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	schoenebeck	2581	return &result;
114			}
115
116	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
117			// built-in script function: abs()
118
119	schoenebeck	2619	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	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
128			// built-in script function: random()
129
130	schoenebeck	2619	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	schoenebeck	2620	float f = float(::rand()) / float(RAND_MAX);
138	schoenebeck	2619	return successResult(
139			iMin + roundf( f * float(iMax - iMin) )
140			);
141			}
142
143	schoenebeck	2727	///////////////////////////////////////////////////////////////////////////
144			// built-in script function: num_elements()
145
146	schoenebeck	2619	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	schoenebeck	2945	///////////////////////////////////////////////////////////////////////////
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	schoenebeck	2965	///////////////////////////////////////////////////////////////////////////
183	schoenebeck	3076	// built-in script function: in_range()
184
185			VMFnResult* CoreVMFunction_in_range::exec(VMFnArgs* args) {
186			int i = args->arg(0)->asInt()->evalInt();
187			int lo = args->arg(1)->asInt()->evalInt();
188			int hi = args->arg(2)->asInt()->evalInt();
189			if (lo > hi) { // swap lo and hi
190			int tmp = lo;
191			lo = hi;
192			hi = tmp;
193			}
194			return successResult(i >= lo && i <= hi);
195			}
196
197			///////////////////////////////////////////////////////////////////////////
198	schoenebeck	2965	// built-in script function: sh_left()
199
200			VMFnResult* CoreVMFunction_sh_left::exec(VMFnArgs* args) {
201			int i = args->arg(0)->asInt()->evalInt();
202			int n = args->arg(1)->asInt()->evalInt();
203			return successResult(i << n);
204			}
205
206			///////////////////////////////////////////////////////////////////////////
207			// built-in script function: sh_right()
208
209			VMFnResult* CoreVMFunction_sh_right::exec(VMFnArgs* args) {
210			int i = args->arg(0)->asInt()->evalInt();
211			int n = args->arg(1)->asInt()->evalInt();
212			return successResult(i >> n);
213			}
214
215	schoenebeck	2970	///////////////////////////////////////////////////////////////////////////
216			// built-in script function: min()
217
218			VMFnResult* CoreVMFunction_min::exec(VMFnArgs* args) {
219			int l = args->arg(0)->asInt()->evalInt();
220			int r = args->arg(1)->asInt()->evalInt();
221			return successResult(l < r ? l : r);
222			}
223
224			///////////////////////////////////////////////////////////////////////////
225			// built-in script function: max()
226
227			VMFnResult* CoreVMFunction_max::exec(VMFnArgs* args) {
228			int l = args->arg(0)->asInt()->evalInt();
229			int r = args->arg(1)->asInt()->evalInt();
230			return successResult(l > r ? l : r);
231			}
232
233	schoenebeck	2581	} // namespace LinuxSampler