src/scriptvm/common.cpp

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

#include "common.h"
#include <iostream>
#include "editor/SourceToken.h"

namespace LinuxSampler {

    ///////////////////////////////////////////////////////////////////////
    // class 'VMUnit'

    static vmfloat _unitFactor(MetricPrefix_t prefix) {
        switch (prefix) {
            case VM_NO_PREFIX:  return 1.f;
            case VM_KILO:       return 1000.f;
            case VM_HECTO:      return 100.f;
            case VM_DECA:       return 10.f;
            case VM_DECI:       return 0.1f;
            case VM_CENTI:      return 0.01f;
            case VM_MILLI:      return 0.001f;
            case VM_MICRO:      return 0.000001f;
        }
        return 1.f;
    }

    vmfloat VMUnit::unitFactor(MetricPrefix_t prefix) {
        return _unitFactor(prefix);
    }

    vmfloat VMUnit::unitFactor(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
        return _unitFactor(prefix1) * _unitFactor(prefix2);
    }

    vmfloat VMUnit::unitFactor(const MetricPrefix_t* prefixes, vmuint size) {
        vmfloat f = VM_NO_FACTOR;
        for (vmuint i = 0; i < size && prefixes[i]; ++i)
            f *= _unitFactor(prefixes[i]);
        return f;
    }

    bool VMUnit::hasUnitFactorNow() const {
        return unitFactor() != VM_NO_FACTOR;
    }

    ///////////////////////////////////////////////////////////////////////
    // class 'VMExpr'

    VMIntExpr* VMExpr::asInt() const {
        return const_cast<VMIntExpr*>( dynamic_cast<const VMIntExpr*>(this) );
    }

    VMRealExpr* VMExpr::asReal() const {
        return const_cast<VMRealExpr*>( dynamic_cast<const VMRealExpr*>(this) );
    }

    VMNumberExpr* VMExpr::asNumber() const {
        return const_cast<VMNumberExpr*>(
            dynamic_cast<const VMNumberExpr*>(this)
        );
    }

    VMStringExpr* VMExpr::asString() const {
        return const_cast<VMStringExpr*>( dynamic_cast<const VMStringExpr*>(this) );
    }

    VMIntArrayExpr* VMExpr::asIntArray() const {
        return const_cast<VMIntArrayExpr*>( dynamic_cast<const VMIntArrayExpr*>(this) );
    }

    VMRealArrayExpr* VMExpr::asRealArray() const {
        return const_cast<VMRealArrayExpr*>(
            dynamic_cast<const VMRealArrayExpr*>(this)
        );
    }

    VMArrayExpr* VMExpr::asArray() const {
        return const_cast<VMArrayExpr*>(
            dynamic_cast<const VMArrayExpr*>(this)
        );
    }

    bool VMExpr::isModifyable() const {
        const VMVariable* var = dynamic_cast<const VMVariable*>(this);
        return (!var) ? false : var->isAssignable();
    }

    bool VMFunction::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
        return type == VM_NO_UNIT;
    }

    bool VMFunction::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
        return false;
    }

    bool VMFunction::acceptsArgFinal(vmint iArg) const {
        return false;
    }

    void VMFunction::checkArgs(VMFnArgs* args,
                               std::function<void(String)> err,
                               std::function<void(String)> wrn)
    {
    }

    void VMFunction::wrnMsg(const String& txt) {
        std::cout << "[ScriptVM] " << txt << std::endl;
    }

    void VMFunction::errMsg(const String& txt) {
        std::cerr << "[ScriptVM] " << txt << std::endl;
    }

    ///////////////////////////////////////////////////////////////////////
    // class 'VMNumberExpr'

    vmint VMNumberExpr::evalCastInt() {
        if (exprType() == INT_EXPR)
            return asInt()->evalInt();
        else
            return vmint( asReal()->evalReal() );
    }

    vmfloat VMNumberExpr::evalCastReal() {
        if (exprType() == REAL_EXPR)
            return asReal()->evalReal();
        else
            return vmfloat( asInt()->evalInt() );
    }

    vmint VMNumberExpr::evalCastInt(MetricPrefix_t prefix) {
        vmfloat f = evalCastReal();
        vmfloat factor = unitFactor() / _unitFactor(prefix);
        return vmint(f * factor);
    }

    vmint VMNumberExpr::evalCastInt(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
        vmfloat f = evalCastReal();
        vmfloat factor = unitFactor() /
                            ( _unitFactor(prefix1) * _unitFactor(prefix2) );
        return vmint(f * factor);
    }

    vmfloat VMNumberExpr::evalCastReal(MetricPrefix_t prefix) {
        vmfloat f = evalCastReal();
        vmfloat factor = unitFactor() / _unitFactor(prefix);
        return f * factor;
    }

    vmfloat VMNumberExpr::evalCastReal(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
        vmfloat f = evalCastReal();
        vmfloat factor = unitFactor() /
                            ( _unitFactor(prefix1) * _unitFactor(prefix2) );
        return f * factor;
    }

    ///////////////////////////////////////////////////////////////////////
    // class 'VMIntExpr'

    vmint VMIntExpr::evalInt(MetricPrefix_t prefix) {
        vmfloat f = (vmfloat) evalInt();
        vmfloat factor = unitFactor() / _unitFactor(prefix);
        return vmint(f * factor);
    }

    vmint VMIntExpr::evalInt(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
        vmfloat f = (vmfloat) evalInt();
        vmfloat factor = unitFactor() /
                            ( _unitFactor(prefix1) * _unitFactor(prefix2) );
        return vmint(f * factor);
    }

    ///////////////////////////////////////////////////////////////////////
    // class 'VMRealExpr'

    vmfloat VMRealExpr::evalReal(MetricPrefix_t prefix) {
        vmfloat f = evalReal();
        vmfloat factor = unitFactor() / _unitFactor(prefix);
        return f * factor;
    }

    vmfloat VMRealExpr::evalReal(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
        vmfloat f = evalReal();
        vmfloat factor = unitFactor() /
                            ( _unitFactor(prefix1) * _unitFactor(prefix2) );
        return f * factor;
    }

    ///////////////////////////////////////////////////////////////////////
    // class 'VMSourceToken'

    VMSourceToken::VMSourceToken() : m_token(NULL) {
    }

    VMSourceToken::VMSourceToken(SourceToken* ct) : m_token(ct) {
    }

    VMSourceToken::VMSourceToken(const VMSourceToken& other) {
        if (other.m_token) {
            m_token = new SourceToken;
            *m_token = *other.m_token;
        } else m_token = NULL;
    }

    VMSourceToken::~VMSourceToken() {
        if (m_token) {
            delete m_token;
            m_token = NULL;
        }
    }

    VMSourceToken& VMSourceToken::operator=(const VMSourceToken& other) {
        if (m_token) delete m_token;
        if (other.m_token) {
            m_token = new SourceToken;
            *m_token = *other.m_token;
        } else m_token = NULL;
        return *this;
    }

    String VMSourceToken::text() const {
        return (m_token) ? m_token->text() : "";
    }

    int VMSourceToken::firstLine() const {
        return (m_token) ? m_token->firstLine() : 0;
    }

    int VMSourceToken::firstColumn() const {
        return (m_token) ? m_token->firstColumn() : 0;
    }

    int VMSourceToken::firstByte() const {
        return (m_token) ? m_token->firstByte() : 0;
    }

    int VMSourceToken::lengthBytes() const {
        return (m_token) ? m_token->lengthBytes() : 0;
    }

    bool VMSourceToken::isEOF() const {
        return (m_token) ? m_token->isEOF() : true;
    }

    bool VMSourceToken::isNewLine() const {
        return (m_token) ? m_token->isNewLine() : false;
    }

    bool VMSourceToken::isKeyword() const {
        return (m_token) ? m_token->isKeyword() : false;
    }

    bool VMSourceToken::isVariableName() const {
        return (m_token) ? m_token->isVariableName() : false;
    }

    bool VMSourceToken::isIdentifier() const {
        return (m_token) ? m_token->isIdentifier() : false;
    }

    bool VMSourceToken::isNumberLiteral() const {
        return (m_token) ? m_token->isNumberLiteral() : false;
    }

    bool VMSourceToken::isStringLiteral() const {
        return (m_token) ? m_token->isStringLiteral() : false;
    }

    bool VMSourceToken::isComment() const {
        return (m_token) ? m_token->isComment() : false;
    }

    bool VMSourceToken::isPreprocessor() const {
        return (m_token) ? m_token->isPreprocessor() : false;
    }

    bool VMSourceToken::isMetricPrefix() const {
        return (m_token) ? m_token->isMetricPrefix() : false;
    }

    bool VMSourceToken::isStdUnit() const {
        return (m_token) ? m_token->isStdUnit() : false;
    }

    bool VMSourceToken::isOther() const {
        return (m_token) ? m_token->isOther() : true;
    }

    bool VMSourceToken::isIntegerVariable() const {
        return (m_token) ? m_token->isIntegerVariable() : false;
    }

    bool VMSourceToken::isRealVariable() const {
        return (m_token) ? m_token->isRealVariable() : false;
    }

    bool VMSourceToken::isStringVariable() const {
        return (m_token) ? m_token->isStringVariable() : false;
    }

    bool VMSourceToken::isIntArrayVariable() const {
        return (m_token) ? m_token->isIntegerArrayVariable() : false;
    }

    bool VMSourceToken::isRealArrayVariable() const {
        return (m_token) ? m_token->isRealArrayVariable() : false;
    }

    bool VMSourceToken::isArrayVariable() const { // deprecated API: will be removed !
        return isIntArrayVariable();
    }

    bool VMSourceToken::isEventHandlerName() const {
        return (m_token) ? m_token->isEventHandlerName() : false;
    }

} // namespace LinuxSampler
1	/*
2	* Copyright (c) 2014-2020 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 "common.h"
11	#include <iostream>
12	#include "editor/SourceToken.h"
13
14	namespace LinuxSampler {
15
16	///////////////////////////////////////////////////////////////////////
17	// class 'VMUnit'
18
19	static vmfloat _unitFactor(MetricPrefix_t prefix) {
20	switch (prefix) {
21	case VM_NO_PREFIX: return 1.f;
22	case VM_KILO: return 1000.f;
23	case VM_HECTO: return 100.f;
24	case VM_DECA: return 10.f;
25	case VM_DECI: return 0.1f;
26	case VM_CENTI: return 0.01f;
27	case VM_MILLI: return 0.001f;
28	case VM_MICRO: return 0.000001f;
29	}
30	return 1.f;
31	}
32
33	vmfloat VMUnit::unitFactor(MetricPrefix_t prefix) {
34	return _unitFactor(prefix);
35	}
36
37	vmfloat VMUnit::unitFactor(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
38	return _unitFactor(prefix1) * _unitFactor(prefix2);
39	}
40
41	vmfloat VMUnit::unitFactor(const MetricPrefix_t* prefixes, vmuint size) {
42	vmfloat f = VM_NO_FACTOR;
43	for (vmuint i = 0; i < size && prefixes[i]; ++i)
44	f *= _unitFactor(prefixes[i]);
45	return f;
46	}
47
48	bool VMUnit::hasUnitFactorNow() const {
49	return unitFactor() != VM_NO_FACTOR;
50	}
51
52	///////////////////////////////////////////////////////////////////////
53	// class 'VMExpr'
54
55	VMIntExpr* VMExpr::asInt() const {
56	return const_cast<VMIntExpr>( dynamic_cast<const VMIntExpr>(this) );
57	}
58
59	VMRealExpr* VMExpr::asReal() const {
60	return const_cast<VMRealExpr>( dynamic_cast<const VMRealExpr>(this) );
61	}
62
63	VMNumberExpr* VMExpr::asNumber() const {
64	return const_cast<VMNumberExpr*>(
65	dynamic_cast<const VMNumberExpr*>(this)
66	);
67	}
68
69	VMStringExpr* VMExpr::asString() const {
70	return const_cast<VMStringExpr>( dynamic_cast<const VMStringExpr>(this) );
71	}
72
73	VMIntArrayExpr* VMExpr::asIntArray() const {
74	return const_cast<VMIntArrayExpr>( dynamic_cast<const VMIntArrayExpr>(this) );
75	}
76
77	VMRealArrayExpr* VMExpr::asRealArray() const {
78	return const_cast<VMRealArrayExpr*>(
79	dynamic_cast<const VMRealArrayExpr*>(this)
80	);
81	}
82
83	VMArrayExpr* VMExpr::asArray() const {
84	return const_cast<VMArrayExpr*>(
85	dynamic_cast<const VMArrayExpr*>(this)
86	);
87	}
88
89	bool VMExpr::isModifyable() const {
90	const VMVariable* var = dynamic_cast<const VMVariable*>(this);
91	return (!var) ? false : var->isAssignable();
92	}
93
94	bool VMFunction::acceptsArgUnitType(vmint iArg, StdUnit_t type) const {
95	return type == VM_NO_UNIT;
96	}
97
98	bool VMFunction::acceptsArgUnitPrefix(vmint iArg, StdUnit_t type) const {
99	return false;
100	}
101
102	bool VMFunction::acceptsArgFinal(vmint iArg) const {
103	return false;
104	}
105
106	void VMFunction::checkArgs(VMFnArgs* args,
107	std::function<void(String)> err,
108	std::function<void(String)> wrn)
109	{
110	}
111
112	void VMFunction::wrnMsg(const String& txt) {
113	std::cout << "[ScriptVM] " << txt << std::endl;
114	}
115
116	void VMFunction::errMsg(const String& txt) {
117	std::cerr << "[ScriptVM] " << txt << std::endl;
118	}
119
120	///////////////////////////////////////////////////////////////////////
121	// class 'VMNumberExpr'
122
123	vmint VMNumberExpr::evalCastInt() {
124	if (exprType() == INT_EXPR)
125	return asInt()->evalInt();
126	else
127	return vmint( asReal()->evalReal() );
128	}
129
130	vmfloat VMNumberExpr::evalCastReal() {
131	if (exprType() == REAL_EXPR)
132	return asReal()->evalReal();
133	else
134	return vmfloat( asInt()->evalInt() );
135	}
136
137	vmint VMNumberExpr::evalCastInt(MetricPrefix_t prefix) {
138	vmfloat f = evalCastReal();
139	vmfloat factor = unitFactor() / _unitFactor(prefix);
140	return vmint(f * factor);
141	}
142
143	vmint VMNumberExpr::evalCastInt(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
144	vmfloat f = evalCastReal();
145	vmfloat factor = unitFactor() /
146	( _unitFactor(prefix1) * _unitFactor(prefix2) );
147	return vmint(f * factor);
148	}
149
150	vmfloat VMNumberExpr::evalCastReal(MetricPrefix_t prefix) {
151	vmfloat f = evalCastReal();
152	vmfloat factor = unitFactor() / _unitFactor(prefix);
153	return f * factor;
154	}
155
156	vmfloat VMNumberExpr::evalCastReal(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
157	vmfloat f = evalCastReal();
158	vmfloat factor = unitFactor() /
159	( _unitFactor(prefix1) * _unitFactor(prefix2) );
160	return f * factor;
161	}
162
163	///////////////////////////////////////////////////////////////////////
164	// class 'VMIntExpr'
165
166	vmint VMIntExpr::evalInt(MetricPrefix_t prefix) {
167	vmfloat f = (vmfloat) evalInt();
168	vmfloat factor = unitFactor() / _unitFactor(prefix);
169	return vmint(f * factor);
170	}
171
172	vmint VMIntExpr::evalInt(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
173	vmfloat f = (vmfloat) evalInt();
174	vmfloat factor = unitFactor() /
175	( _unitFactor(prefix1) * _unitFactor(prefix2) );
176	return vmint(f * factor);
177	}
178
179	///////////////////////////////////////////////////////////////////////
180	// class 'VMRealExpr'
181
182	vmfloat VMRealExpr::evalReal(MetricPrefix_t prefix) {
183	vmfloat f = evalReal();
184	vmfloat factor = unitFactor() / _unitFactor(prefix);
185	return f * factor;
186	}
187
188	vmfloat VMRealExpr::evalReal(MetricPrefix_t prefix1, MetricPrefix_t prefix2) {
189	vmfloat f = evalReal();
190	vmfloat factor = unitFactor() /
191	( _unitFactor(prefix1) * _unitFactor(prefix2) );
192	return f * factor;
193	}
194
195	///////////////////////////////////////////////////////////////////////
196	// class 'VMSourceToken'
197
198	VMSourceToken::VMSourceToken() : m_token(NULL) {
199	}
200
201	VMSourceToken::VMSourceToken(SourceToken* ct) : m_token(ct) {
202	}
203
204	VMSourceToken::VMSourceToken(const VMSourceToken& other) {
205	if (other.m_token) {
206	m_token = new SourceToken;
207	m_token = other.m_token;
208	} else m_token = NULL;
209	}
210
211	VMSourceToken::~VMSourceToken() {
212	if (m_token) {
213	delete m_token;
214	m_token = NULL;
215	}
216	}
217
218	VMSourceToken& VMSourceToken::operator=(const VMSourceToken& other) {
219	if (m_token) delete m_token;
220	if (other.m_token) {
221	m_token = new SourceToken;
222	m_token = other.m_token;
223	} else m_token = NULL;
224	return *this;
225	}
226
227	String VMSourceToken::text() const {
228	return (m_token) ? m_token->text() : "";
229	}
230
231	int VMSourceToken::firstLine() const {
232	return (m_token) ? m_token->firstLine() : 0;
233	}
234
235	int VMSourceToken::firstColumn() const {
236	return (m_token) ? m_token->firstColumn() : 0;
237	}
238
239	int VMSourceToken::firstByte() const {
240	return (m_token) ? m_token->firstByte() : 0;
241	}
242
243	int VMSourceToken::lengthBytes() const {
244	return (m_token) ? m_token->lengthBytes() : 0;
245	}
246
247	bool VMSourceToken::isEOF() const {
248	return (m_token) ? m_token->isEOF() : true;
249	}
250
251	bool VMSourceToken::isNewLine() const {
252	return (m_token) ? m_token->isNewLine() : false;
253	}
254
255	bool VMSourceToken::isKeyword() const {
256	return (m_token) ? m_token->isKeyword() : false;
257	}
258
259	bool VMSourceToken::isVariableName() const {
260	return (m_token) ? m_token->isVariableName() : false;
261	}
262
263	bool VMSourceToken::isIdentifier() const {
264	return (m_token) ? m_token->isIdentifier() : false;
265	}
266
267	bool VMSourceToken::isNumberLiteral() const {
268	return (m_token) ? m_token->isNumberLiteral() : false;
269	}
270
271	bool VMSourceToken::isStringLiteral() const {
272	return (m_token) ? m_token->isStringLiteral() : false;
273	}
274
275	bool VMSourceToken::isComment() const {
276	return (m_token) ? m_token->isComment() : false;
277	}
278
279	bool VMSourceToken::isPreprocessor() const {
280	return (m_token) ? m_token->isPreprocessor() : false;
281	}
282
283	bool VMSourceToken::isMetricPrefix() const {
284	return (m_token) ? m_token->isMetricPrefix() : false;
285	}
286
287	bool VMSourceToken::isStdUnit() const {
288	return (m_token) ? m_token->isStdUnit() : false;
289	}
290
291	bool VMSourceToken::isOther() const {
292	return (m_token) ? m_token->isOther() : true;
293	}
294
295	bool VMSourceToken::isIntegerVariable() const {
296	return (m_token) ? m_token->isIntegerVariable() : false;
297	}
298
299	bool VMSourceToken::isRealVariable() const {
300	return (m_token) ? m_token->isRealVariable() : false;
301	}
302
303	bool VMSourceToken::isStringVariable() const {
304	return (m_token) ? m_token->isStringVariable() : false;
305	}
306
307	bool VMSourceToken::isIntArrayVariable() const {
308	return (m_token) ? m_token->isIntegerArrayVariable() : false;
309	}
310
311	bool VMSourceToken::isRealArrayVariable() const {
312	return (m_token) ? m_token->isRealArrayVariable() : false;
313	}
314
315	bool VMSourceToken::isArrayVariable() const { // deprecated API: will be removed !
316	return isIntArrayVariable();
317	}
318
319	bool VMSourceToken::isEventHandlerName() const {
320	return (m_token) ? m_token->isEventHandlerName() : false;
321	}
322
323	} // namespace LinuxSampler