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:  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	/*
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