src/scriptvm/CoreVMFunctions.h

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

#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 { return EMPTY_EXPR; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { 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
    int value; ///< result value of the function call

    VMIntResult() : flags(STMT_SUCCESS) {}
    int evalInt() { return value; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { return flags; }
    bool isConstExpr() 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() { return value; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { 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:
    ExprType_t returnType() { return EMPTY_EXPR; }
    VMFnResult* errorResult();
    VMFnResult* successResult();
    bool modifiesArg(int 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:
    ExprType_t returnType() { return INT_EXPR; }
    VMFnResult* errorResult(int i = 0);
    VMFnResult* successResult(int i = 0);
    bool modifiesArg(int 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:
    ExprType_t returnType() { return STRING_EXPR; }
    VMFnResult* errorResult(const String& s = "");
    VMFnResult* successResult(const String& s = "");
    bool modifiesArg(int 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:
    int minRequiredArgs() const { return 1; }
    int maxAllowedArgs() const { return 1; }
    bool acceptsArgType(int iArg, ExprType_t type) const;
    ExprType_t argType(int iArg) const { return STRING_EXPR; }
    VMFnResult* exec(VMFnArgs* args);
};

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

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

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

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

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

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

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

} // namespace LinuxSampler

#endif // LS_COREVMFUNCTIONS_H
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			#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			ExprType_t exprType() const { return EMPTY_EXPR; }
33			VMExpr* resultValue() { return this; }
34			StmtFlags_t resultFlags() { 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			int value; ///< result value of the function call
46	schoenebeck	2598
47			VMIntResult() : flags(STMT_SUCCESS) {}
48			int evalInt() { return value; }
49			VMExpr* resultValue() { return this; }
50			StmtFlags_t resultFlags() { return flags; }
51	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
52	schoenebeck	2598	};
53
54	schoenebeck	2727	/**
55			* An instance of this class is returned by built-in function implementations
56			* which return a string value as function return value.
57			*/
58	schoenebeck	2581	class VMStringResult : public VMFnResult, public VMStringExpr {
59			public:
60	schoenebeck	2727	StmtFlags_t flags; ///< general completion status (i.e. success or failure) of the function call
61			String value; ///< result value of the function call
62	schoenebeck	2581
63			VMStringResult() : flags(STMT_SUCCESS) {}
64			String evalStr() { return value; }
65			VMExpr* resultValue() { return this; }
66			StmtFlags_t resultFlags() { return flags; }
67	schoenebeck	2945	bool isConstExpr() const OVERRIDE { return false; }
68	schoenebeck	2581	};
69
70	schoenebeck	2727	/**
71			* Abstract base class for built-in script functions which do not return any
72			* function return value (void).
73			*/
74	schoenebeck	2581	class VMEmptyResultFunction : public VMFunction {
75			protected:
76			ExprType_t returnType() { return EMPTY_EXPR; }
77			VMFnResult* errorResult();
78			VMFnResult* successResult();
79	schoenebeck	2945	bool modifiesArg(int iArg) const OVERRIDE { return false; }
80	schoenebeck	2581	protected:
81			VMEmptyResult result;
82			};
83
84	schoenebeck	2727	/**
85			* Abstract base class for built-in script functions which return an integer
86			* (scalar) as their function return value.
87			*/
88	schoenebeck	2598	class VMIntResultFunction : public VMFunction {
89			protected:
90			ExprType_t returnType() { return INT_EXPR; }
91			VMFnResult* errorResult(int i = 0);
92			VMFnResult* successResult(int i = 0);
93	schoenebeck	2945	bool modifiesArg(int iArg) const OVERRIDE { return false; }
94	schoenebeck	2598	protected:
95			VMIntResult result;
96			};
97
98	schoenebeck	2727	/**
99			* Abstract base class for built-in script functions which return a string as
100			* their function return value.
101			*/
102	schoenebeck	2581	class VMStringResultFunction : public VMFunction {
103			protected:
104			ExprType_t returnType() { return STRING_EXPR; }
105			VMFnResult* errorResult(const String& s = "");
106			VMFnResult* successResult(const String& s = "");
107	schoenebeck	2945	bool modifiesArg(int iArg) const OVERRIDE { return false; }
108	schoenebeck	2581	protected:
109			VMStringResult result;
110			};
111
112	schoenebeck	2727
113			///////////////////////////////////////////////////////////////////////////
114			// implementations of core built-in script functions ...
115
116			/**
117			* Implements the built-in message() script function.
118			*/
119	schoenebeck	2581	class CoreVMFunction_message : public VMEmptyResultFunction {
120			public:
121			int minRequiredArgs() const { return 1; }
122			int maxAllowedArgs() const { return 1; }
123			bool acceptsArgType(int iArg, ExprType_t type) const;
124			ExprType_t argType(int iArg) const { return STRING_EXPR; }
125			VMFnResult* exec(VMFnArgs* args);
126			};
127
128	schoenebeck	2727	/**
129			* Implements the built-in exit() script function.
130			*/
131	schoenebeck	2581	class CoreVMFunction_exit : public VMEmptyResultFunction {
132			public:
133			int minRequiredArgs() const { return 0; }
134			int maxAllowedArgs() const { return 0; }
135			bool acceptsArgType(int iArg, ExprType_t type) const { return false; }
136			ExprType_t argType(int iArg) const { return INT_EXPR; /whatever/ }
137			VMFnResult* exec(VMFnArgs* args);
138			};
139
140	schoenebeck	2727	/**
141			* Implements the built-in wait() script function.
142			*/
143	schoenebeck	2581	class CoreVMFunction_wait : public VMEmptyResultFunction {
144			public:
145			CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
146			int minRequiredArgs() const { return 1; }
147			int maxAllowedArgs() const { return 1; }
148			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
149			ExprType_t argType(int iArg) const { return INT_EXPR; }
150			VMFnResult* exec(VMFnArgs* args);
151			protected:
152			ScriptVM* vm;
153			};
154
155	schoenebeck	2727	/**
156			* Implements the built-in abs() script function.
157			*/
158	schoenebeck	2619	class CoreVMFunction_abs : public VMIntResultFunction {
159			public:
160			int minRequiredArgs() const { return 1; }
161			int maxAllowedArgs() const { return 1; }
162			bool acceptsArgType(int iArg, ExprType_t type) const;
163			ExprType_t argType(int iArg) const { return INT_EXPR; }
164			VMFnResult* exec(VMFnArgs* args);
165			};
166
167	schoenebeck	2727	/**
168			* Implements the built-in random() script function.
169			*/
170	schoenebeck	2619	class CoreVMFunction_random : public VMIntResultFunction {
171			public:
172			int minRequiredArgs() const { return 2; }
173			int maxAllowedArgs() const { return 2; }
174			bool acceptsArgType(int iArg, ExprType_t type) const;
175			ExprType_t argType(int iArg) const { return INT_EXPR; }
176			VMFnResult* exec(VMFnArgs* args);
177			};
178
179	schoenebeck	2727	/**
180			* Implements the built-in num_elements() script function.
181			*/
182	schoenebeck	2619	class CoreVMFunction_num_elements : public VMIntResultFunction {
183			public:
184			int minRequiredArgs() const { return 1; }
185			int maxAllowedArgs() const { return 1; }
186			bool acceptsArgType(int iArg, ExprType_t type) const;
187			ExprType_t argType(int iArg) const { return INT_ARR_EXPR; }
188			VMFnResult* exec(VMFnArgs* args);
189			};
190
191	schoenebeck	2945	/**
192			* Implements the built-in inc() script function.
193			*/
194			class CoreVMFunction_inc : public VMIntResultFunction {
195			public:
196			int minRequiredArgs() const { return 1; }
197			int maxAllowedArgs() const { return 1; }
198			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
199			ExprType_t argType(int iArg) const { return INT_EXPR; }
200			bool modifiesArg(int iArg) const { return true; }
201			VMFnResult* exec(VMFnArgs* args);
202			};
203
204			/**
205			* Implements the built-in dec() script function.
206			*/
207			class CoreVMFunction_dec : public VMIntResultFunction {
208			public:
209			int minRequiredArgs() const { return 1; }
210			int maxAllowedArgs() const { return 1; }
211			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
212			ExprType_t argType(int iArg) const { return INT_EXPR; }
213			bool modifiesArg(int iArg) const { return true; }
214			VMFnResult* exec(VMFnArgs* args);
215			};
216
217	schoenebeck	2581	} // namespace LinuxSampler
218
219			#endif // LS_COREVMFUNCTIONS_H