src/scriptvm/CoreVMFunctions.h

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

#ifndef LS_COREVMFUNCTIONS_H
#define LS_COREVMFUNCTIONS_H

#include "../common/global.h"
#include "common.h"

namespace LinuxSampler {
    
class ScriptVM;

///////////////////////////////////////////////////////////////////////////
// convenience base classes for built-in script functions ...

/**
 * An instance of this class is returned by built-in function implementations
 * which do not return a function return value.
 */
class VMEmptyResult : public VMFnResult, public VMExpr {
public:
    StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call

    VMEmptyResult() : flags(STMT_SUCCESS) {}
    ExprType_t exprType() const OVERRIDE { return EMPTY_EXPR; }
    VMExpr* resultValue() OVERRIDE { return this; }
    StmtFlags_t resultFlags() OVERRIDE { return flags; }
    bool isConstExpr() const OVERRIDE { return false; }
};

/**
 * An instance of this class is returned by built-in function implementations
 * which return an integer value as function return value.
 */
class VMIntResult : public VMFnResult, public VMIntExpr {
public:
    StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
    vmint value; ///< result value of the function call

    VMIntResult() : flags(STMT_SUCCESS), value(0) {}
    vmint evalInt() OVERRIDE { return value; }
    VMExpr* resultValue() OVERRIDE { return this; }
    StmtFlags_t resultFlags() OVERRIDE { return flags; }
    bool isConstExpr() const OVERRIDE { return false; }
    MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
    StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
    bool isFinal() const OVERRIDE { return false; }
};

/**
 * An instance of this class is returned by built-in function implementations
 * which return a string value as function return value.
 */
class VMStringResult : public VMFnResult, public VMStringExpr {
public:
    StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
    String value; ///< result value of the function call

    VMStringResult() : flags(STMT_SUCCESS) {}
    String evalStr() OVERRIDE { return value; }
    VMExpr* resultValue() OVERRIDE { return this; }
    StmtFlags_t resultFlags() OVERRIDE { return flags; }
    bool isConstExpr() const OVERRIDE { return false; }
};

/**
 * Abstract base class for built-in script functions which do not return any
 * function return value (void).
 */
class VMEmptyResultFunction : public VMFunction {
protected:
    virtual ~VMEmptyResultFunction() {}
    ExprType_t returnType() OVERRIDE { return EMPTY_EXPR; }
    VMFnResult* errorResult();
    VMFnResult* successResult();
    bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
protected:
    VMEmptyResult result;
};

/**
 * Abstract base class for built-in script functions which return an integer
 * (scalar) as their function return value.
 */
class VMIntResultFunction : public VMFunction {
protected:
    virtual ~VMIntResultFunction() {}
    ExprType_t returnType() OVERRIDE { return INT_EXPR; }
    VMFnResult* errorResult(vmint i = 0);
    VMFnResult* successResult(vmint i = 0);
    bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
protected:
    VMIntResult result;
};

/**
 * Abstract base class for built-in script functions which return a string as
 * their function return value.
 */
class VMStringResultFunction : public VMFunction {
protected:
    virtual ~VMStringResultFunction() {}
    ExprType_t returnType() OVERRIDE { return STRING_EXPR; }
    VMFnResult* errorResult(const String& s = "");
    VMFnResult* successResult(const String& s = "");
    bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
protected:
    VMStringResult result;
};


///////////////////////////////////////////////////////////////////////////
// implementations of core built-in script functions ...

/**
 * Implements the built-in message() script function.
 */
class CoreVMFunction_message : public VMEmptyResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return STRING_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in exit() script function.
 */
class CoreVMFunction_exit : public VMEmptyResultFunction {
public:
    CoreVMFunction_exit(ScriptVM* vm) : vm(vm) {}
    vmint minRequiredArgs() const OVERRIDE { return 0; }
    vmint maxAllowedArgs() const OVERRIDE;
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
protected:
    ScriptVM* vm;
};

/**
 * Implements the built-in wait() script function.
 */
class CoreVMFunction_wait : public VMEmptyResultFunction {
public:
    CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
    bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
protected:
    ScriptVM* vm;
};

/**
 * Implements the built-in abs() script function.
 */
class CoreVMFunction_abs : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in random() script function.
 */
class CoreVMFunction_random : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in num_elements() script function.
 */
class CoreVMFunction_num_elements : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_ARR_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in inc() script function.
 */
class CoreVMFunction_inc : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in dec() script function.
 */
class CoreVMFunction_dec : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 1; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in in_range() script function.
 */
class CoreVMFunction_in_range : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 3; }
    vmint maxAllowedArgs() const OVERRIDE { return 3; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in sh_left() script function.
 */
class CoreVMFunction_sh_left : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in sh_right() script function.
 */
class CoreVMFunction_sh_right : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in min() script function.
 */
class CoreVMFunction_min : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in max() script function.
 */
class CoreVMFunction_max : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in array_equal() script function.
 */
class CoreVMFunction_array_equal : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_ARR_EXPR; }
    ExprType_t argType(vmint iArg) const OVERRIDE { return INT_ARR_EXPR; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in search() script function.
 */
class CoreVMFunction_search : public VMIntResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 2; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE;
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

/**
 * Implements the built-in sort() script function.
 */
class CoreVMFunction_sort : public VMEmptyResultFunction {
public:
    vmint minRequiredArgs() const OVERRIDE { return 1; }
    vmint maxAllowedArgs() const OVERRIDE { return 2; }
    bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
    ExprType_t argType(vmint iArg) const OVERRIDE;
    bool modifiesArg(vmint iArg) const OVERRIDE { return iArg == 0; }
    VMFnResult* exec(VMFnArgs* args) OVERRIDE;
};

} // namespace LinuxSampler

#endif // LS_COREVMFUNCTIONS_H
1	schoenebeck	2581	/*
2	schoenebeck	3551	* Copyright (c) 2014-2019 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			#ifndef LS_COREVMFUNCTIONS_H
11			#define LS_COREVMFUNCTIONS_H
12
13			#include "../common/global.h"
14			#include "common.h"
15
16			namespace LinuxSampler {
17
18			class ScriptVM;
19	schoenebeck	2727
20			///////////////////////////////////////////////////////////////////////////
21			// convenience base classes for built-in script functions ...
22
23			/**
24			* An instance of this class is returned by built-in function implementations
25			* which do not return a function return value.
26			*/
27	schoenebeck	2581	class VMEmptyResult : public VMFnResult, public VMExpr {
28			public:
29	schoenebeck	2727	StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
30	schoenebeck	2581
31			VMEmptyResult() : flags(STMT_SUCCESS) {}
32	schoenebeck	3054	ExprType_t exprType() const OVERRIDE { return EMPTY_EXPR; }
33			VMExpr* resultValue() OVERRIDE { return this; }
34			StmtFlags_t resultFlags() OVERRIDE { return flags; }
35	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
36	schoenebeck	2581	};
37
38	schoenebeck	2727	/**
39			* An instance of this class is returned by built-in function implementations
40			* which return an integer value as function return value.
41			*/
42	schoenebeck	2598	class VMIntResult : public VMFnResult, public VMIntExpr {
43			public:
44	schoenebeck	2727	StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
45	schoenebeck	3557	vmint value; ///< result value of the function call
46	schoenebeck	2598
47	schoenebeck	3561	VMIntResult() : flags(STMT_SUCCESS), value(0) {}
48	schoenebeck	3557	vmint evalInt() OVERRIDE { return value; }
49	schoenebeck	3054	VMExpr* resultValue() OVERRIDE { return this; }
50			StmtFlags_t resultFlags() OVERRIDE { return flags; }
51	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
52	schoenebeck	3561	MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
53			StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
54			bool isFinal() const OVERRIDE { return false; }
55	schoenebeck	2598	};
56
57	schoenebeck	2727	/**
58			* An instance of this class is returned by built-in function implementations
59			* which return a string value as function return value.
60			*/
61	schoenebeck	2581	class VMStringResult : public VMFnResult, public VMStringExpr {
62			public:
63	schoenebeck	2727	StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
64			String value; ///< result value of the function call
65	schoenebeck	2581
66			VMStringResult() : flags(STMT_SUCCESS) {}
67	schoenebeck	3054	String evalStr() OVERRIDE { return value; }
68			VMExpr* resultValue() OVERRIDE { return this; }
69			StmtFlags_t resultFlags() OVERRIDE { return flags; }
70	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
71	schoenebeck	2581	};
72
73	schoenebeck	2727	/**
74			* Abstract base class for built-in script functions which do not return any
75			* function return value (void).
76			*/
77	schoenebeck	2581	class VMEmptyResultFunction : public VMFunction {
78			protected:
79	schoenebeck	3034	virtual ~VMEmptyResultFunction() {}
80	schoenebeck	3054	ExprType_t returnType() OVERRIDE { return EMPTY_EXPR; }
81	schoenebeck	2581	VMFnResult* errorResult();
82			VMFnResult* successResult();
83	schoenebeck	3557	bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
84	schoenebeck	2581	protected:
85			VMEmptyResult result;
86			};
87
88	schoenebeck	2727	/**
89			* Abstract base class for built-in script functions which return an integer
90			* (scalar) as their function return value.
91			*/
92	schoenebeck	2598	class VMIntResultFunction : public VMFunction {
93			protected:
94	schoenebeck	3034	virtual ~VMIntResultFunction() {}
95	schoenebeck	3054	ExprType_t returnType() OVERRIDE { return INT_EXPR; }
96	schoenebeck	3557	VMFnResult* errorResult(vmint i = 0);
97			VMFnResult* successResult(vmint i = 0);
98			bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
99	schoenebeck	2598	protected:
100			VMIntResult result;
101			};
102
103	schoenebeck	2727	/**
104			* Abstract base class for built-in script functions which return a string as
105			* their function return value.
106			*/
107	schoenebeck	2581	class VMStringResultFunction : public VMFunction {
108			protected:
109	schoenebeck	3034	virtual ~VMStringResultFunction() {}
110	schoenebeck	3054	ExprType_t returnType() OVERRIDE { return STRING_EXPR; }
111	schoenebeck	2581	VMFnResult* errorResult(const String& s = "");
112			VMFnResult* successResult(const String& s = "");
113	schoenebeck	3557	bool modifiesArg(vmint iArg) const OVERRIDE { return false; }
114	schoenebeck	2581	protected:
115			VMStringResult result;
116			};
117
118	schoenebeck	2727
119			///////////////////////////////////////////////////////////////////////////
120			// implementations of core built-in script functions ...
121
122			/**
123			* Implements the built-in message() script function.
124			*/
125	schoenebeck	2581	class CoreVMFunction_message : public VMEmptyResultFunction {
126			public:
127	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
128			vmint maxAllowedArgs() const OVERRIDE { return 1; }
129			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
130			ExprType_t argType(vmint iArg) const OVERRIDE { return STRING_EXPR; }
131			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
132	schoenebeck	2581	};
133
134	schoenebeck	2727	/**
135			* Implements the built-in exit() script function.
136			*/
137	schoenebeck	2581	class CoreVMFunction_exit : public VMEmptyResultFunction {
138			public:
139	schoenebeck	3551	CoreVMFunction_exit(ScriptVM* vm) : vm(vm) {}
140	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 0; }
141			vmint maxAllowedArgs() const OVERRIDE;
142			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
143			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
144			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
145	schoenebeck	3551	protected:
146			ScriptVM* vm;
147	schoenebeck	2581	};
148
149	schoenebeck	2727	/**
150			* Implements the built-in wait() script function.
151			*/
152	schoenebeck	2581	class CoreVMFunction_wait : public VMEmptyResultFunction {
153			public:
154			CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
155	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
156			vmint maxAllowedArgs() const OVERRIDE { return 1; }
157			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
158	schoenebeck	3561	bool acceptsArgUnitType(vmint iArg, StdUnit_t type) const OVERRIDE;
159	schoenebeck	3564	bool acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const OVERRIDE;
160	schoenebeck	3557	ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
161			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
162	schoenebeck	2581	protected:
163			ScriptVM* vm;
164			};
165
166	schoenebeck	2727	/**
167			* Implements the built-in abs() script function.
168			*/
169	schoenebeck	2619	class CoreVMFunction_abs : public VMIntResultFunction {
170			public:
171	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
172			vmint maxAllowedArgs() const OVERRIDE { return 1; }
173			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
174			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
175			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
176	schoenebeck	2619	};
177
178	schoenebeck	2727	/**
179			* Implements the built-in random() script function.
180			*/
181	schoenebeck	2619	class CoreVMFunction_random : public VMIntResultFunction {
182			public:
183	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
184			vmint maxAllowedArgs() const OVERRIDE { return 2; }
185			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
186			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
187			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
188	schoenebeck	2619	};
189
190	schoenebeck	2727	/**
191			* Implements the built-in num_elements() script function.
192			*/
193	schoenebeck	2619	class CoreVMFunction_num_elements : public VMIntResultFunction {
194			public:
195	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
196			vmint maxAllowedArgs() const OVERRIDE { return 1; }
197			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
198			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_ARR_EXPR; }
199			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
200	schoenebeck	2619	};
201
202	schoenebeck	2945	/**
203			* Implements the built-in inc() script function.
204			*/
205			class CoreVMFunction_inc : public VMIntResultFunction {
206			public:
207	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
208			vmint maxAllowedArgs() const OVERRIDE { return 1; }
209			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
210			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
211			bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
212			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
213	schoenebeck	2945	};
214
215			/**
216			* Implements the built-in dec() script function.
217			*/
218			class CoreVMFunction_dec : public VMIntResultFunction {
219			public:
220	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
221			vmint maxAllowedArgs() const OVERRIDE { return 1; }
222			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
223			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
224			bool modifiesArg(vmint iArg) const OVERRIDE { return true; }
225			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
226	schoenebeck	2945	};
227
228	schoenebeck	2965	/**
229	schoenebeck	3076	* Implements the built-in in_range() script function.
230			*/
231			class CoreVMFunction_in_range : public VMIntResultFunction {
232			public:
233	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 3; }
234			vmint maxAllowedArgs() const OVERRIDE { return 3; }
235			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
236			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
237			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
238	schoenebeck	3076	};
239
240			/**
241	schoenebeck	2965	* Implements the built-in sh_left() script function.
242			*/
243			class CoreVMFunction_sh_left : public VMIntResultFunction {
244			public:
245	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
246			vmint maxAllowedArgs() const OVERRIDE { return 2; }
247			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
248			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
249			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
250	schoenebeck	2965	};
251
252			/**
253			* Implements the built-in sh_right() script function.
254			*/
255			class CoreVMFunction_sh_right : public VMIntResultFunction {
256			public:
257	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
258			vmint maxAllowedArgs() const OVERRIDE { return 2; }
259			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
260			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
261			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
262	schoenebeck	2965	};
263
264	schoenebeck	2970	/**
265			* Implements the built-in min() script function.
266			*/
267			class CoreVMFunction_min : public VMIntResultFunction {
268			public:
269	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
270			vmint maxAllowedArgs() const OVERRIDE { return 2; }
271			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
272			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
273			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
274	schoenebeck	2970	};
275
276			/**
277			* Implements the built-in max() script function.
278			*/
279			class CoreVMFunction_max : public VMIntResultFunction {
280			public:
281	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
282			vmint maxAllowedArgs() const OVERRIDE { return 2; }
283			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_EXPR; }
284			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_EXPR; }
285			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
286	schoenebeck	2970	};
287
288	schoenebeck	3221	/**
289			* Implements the built-in array_equal() script function.
290			*/
291			class CoreVMFunction_array_equal : public VMIntResultFunction {
292			public:
293	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
294			vmint maxAllowedArgs() const OVERRIDE { return 2; }
295			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE { return type == INT_ARR_EXPR; }
296			ExprType_t argType(vmint iArg) const OVERRIDE { return INT_ARR_EXPR; }
297			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
298	schoenebeck	3221	};
299
300			/**
301			* Implements the built-in search() script function.
302			*/
303			class CoreVMFunction_search : public VMIntResultFunction {
304			public:
305	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 2; }
306			vmint maxAllowedArgs() const OVERRIDE { return 2; }
307			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
308			ExprType_t argType(vmint iArg) const OVERRIDE;
309			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
310	schoenebeck	3221	};
311
312			/**
313			* Implements the built-in sort() script function.
314			*/
315			class CoreVMFunction_sort : public VMEmptyResultFunction {
316			public:
317	schoenebeck	3557	vmint minRequiredArgs() const OVERRIDE { return 1; }
318			vmint maxAllowedArgs() const OVERRIDE { return 2; }
319			bool acceptsArgType(vmint iArg, ExprType_t type) const OVERRIDE;
320			ExprType_t argType(vmint iArg) const OVERRIDE;
321			bool modifiesArg(vmint iArg) const OVERRIDE { return iArg == 0; }
322			VMFnResult* exec(VMFnArgs* args) OVERRIDE;
323	schoenebeck	3221	};
324
325	schoenebeck	2581	} // namespace LinuxSampler
326
327			#endif // LS_COREVMFUNCTIONS_H