src/scriptvm/CoreVMFunctions.h

/*
 * Copyright (c) 2014 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;
    
class VMEmptyResult : public VMFnResult, public VMExpr {
public:
    StmtFlags_t flags;

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

class VMStringResult : public VMFnResult, public VMStringExpr {
public:
    StmtFlags_t flags;
    String value;

    VMStringResult() : flags(STMT_SUCCESS) {}
    String evalStr() { return value; }
    VMExpr* resultValue() { return this; }
    StmtFlags_t resultFlags() { return flags; }
};

class VMEmptyResultFunction : public VMFunction {
protected:
    ExprType_t returnType() { return EMPTY_EXPR; }
    VMFnResult* errorResult();
    VMFnResult* successResult();
protected:
    VMEmptyResult result;
};

class VMStringResultFunction : public VMFunction {
protected:
    ExprType_t returnType() { return STRING_EXPR; }
    VMFnResult* errorResult(const String& s = "");
    VMFnResult* successResult(const String& s = "");
protected:
    VMStringResult result;
};

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);
};

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);
};

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;
};

} // namespace LinuxSampler

#endif // LS_COREVMFUNCTIONS_H
1	schoenebeck	2581	/*
2			* Copyright (c) 2014 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			#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
20			class VMEmptyResult : public VMFnResult, public VMExpr {
21			public:
22			StmtFlags_t flags;
23
24			VMEmptyResult() : flags(STMT_SUCCESS) {}
25			ExprType_t exprType() const { return EMPTY_EXPR; }
26			VMExpr* resultValue() { return this; }
27			StmtFlags_t resultFlags() { return flags; }
28			};
29
30			class VMStringResult : public VMFnResult, public VMStringExpr {
31			public:
32			StmtFlags_t flags;
33			String value;
34
35			VMStringResult() : flags(STMT_SUCCESS) {}
36			String evalStr() { return value; }
37			VMExpr* resultValue() { return this; }
38			StmtFlags_t resultFlags() { return flags; }
39			};
40
41			class VMEmptyResultFunction : public VMFunction {
42			protected:
43			ExprType_t returnType() { return EMPTY_EXPR; }
44			VMFnResult* errorResult();
45			VMFnResult* successResult();
46			protected:
47			VMEmptyResult result;
48			};
49
50			class VMStringResultFunction : public VMFunction {
51			protected:
52			ExprType_t returnType() { return STRING_EXPR; }
53			VMFnResult* errorResult(const String& s = "");
54			VMFnResult* successResult(const String& s = "");
55			protected:
56			VMStringResult result;
57			};
58
59			class CoreVMFunction_message : public VMEmptyResultFunction {
60			public:
61			int minRequiredArgs() const { return 1; }
62			int maxAllowedArgs() const { return 1; }
63			bool acceptsArgType(int iArg, ExprType_t type) const;
64			ExprType_t argType(int iArg) const { return STRING_EXPR; }
65			VMFnResult* exec(VMFnArgs* args);
66			};
67
68			class CoreVMFunction_exit : public VMEmptyResultFunction {
69			public:
70			int minRequiredArgs() const { return 0; }
71			int maxAllowedArgs() const { return 0; }
72			bool acceptsArgType(int iArg, ExprType_t type) const { return false; }
73			ExprType_t argType(int iArg) const { return INT_EXPR; /whatever/ }
74			VMFnResult* exec(VMFnArgs* args);
75			};
76
77			class CoreVMFunction_wait : public VMEmptyResultFunction {
78			public:
79			CoreVMFunction_wait(ScriptVM* vm) : vm(vm) {}
80			int minRequiredArgs() const { return 1; }
81			int maxAllowedArgs() const { return 1; }
82			bool acceptsArgType(int iArg, ExprType_t type) const { return type == INT_EXPR; }
83			ExprType_t argType(int iArg) const { return INT_EXPR; }
84			VMFnResult* exec(VMFnArgs* args);
85			protected:
86			ScriptVM* vm;
87			};
88
89			} // namespace LinuxSampler
90
91			#endif // LS_COREVMFUNCTIONS_H