/[svn]/linuxsampler/trunk/src/scriptvm/tree.h
ViewVC logotype

Annotation of /linuxsampler/trunk/src/scriptvm/tree.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3576 - (hide annotations) (download) (as text)
Wed Aug 28 12:56:38 2019 UTC (4 years, 7 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 35274 byte(s)
NKSP: Fixed negate operator which did not work with real numbers.

1 schoenebeck 2581 /* -*- c++ -*-
2     *
3 persson 3455 * Copyright (c) 2014 - 2019 Christian Schoenebeck and Andreas Persson
4 schoenebeck 2581 *
5     * http://www.linuxsampler.org
6     *
7     * This file is part of LinuxSampler and released under the same terms.
8     * See README file for details.
9     */
10    
11     // This header defines VM core implementation internal data types only used
12     // inside the parser and core VM implementation of this source directory. Not
13     // intended to be used in other source code parts (other source code
14     // directories) of the sampler.
15    
16     #ifndef LS_INSTRPARSERTREE_H
17     #define LS_INSTRPARSERTREE_H
18    
19     #include <vector>
20     #include <iostream>
21     #include <map>
22     #include <set>
23 schoenebeck 3208 #include <string.h> // for memset()
24 schoenebeck 2581 #include "../common/global.h"
25     #include "../common/Ref.h"
26     #include "../common/ArrayList.h"
27     #include "common.h"
28    
29     namespace LinuxSampler {
30    
31     class ParserContext;
32     class ExecContext;
33    
34     enum StmtType_t {
35     STMT_LEAF,
36     STMT_LIST,
37     STMT_BRANCH,
38     STMT_LOOP,
39 schoenebeck 3260 STMT_SYNC,
40 schoenebeck 3311 STMT_NOOP,
41 schoenebeck 2581 };
42    
43     class Node {
44     public:
45     Node();
46     virtual ~Node();
47     virtual void dump(int level = 0) = 0;
48 schoenebeck 2645 virtual bool isPolyphonic() const = 0;
49 schoenebeck 2581 void printIndents(int n);
50     };
51     typedef Ref<Node> NodeRef;
52    
53     class Expression : virtual public VMExpr, virtual public Node {
54     public:
55     virtual ExprType_t exprType() const = 0;
56     virtual bool isConstExpr() const = 0;
57     virtual String evalCastToStr() = 0;
58     };
59     typedef Ref<Expression,Node> ExpressionRef;
60    
61 schoenebeck 3573 class Unit : virtual public VMUnit, virtual public Node {
62     ArrayList<MetricPrefix_t> prefix;
63     StdUnit_t unit;
64 schoenebeck 2581 public:
65 schoenebeck 3573 Unit() : unit(VM_NO_UNIT) {}
66     MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE;
67     StdUnit_t unitType() const OVERRIDE { return unit; }
68     void setUnit(const std::vector<MetricPrefix_t>& prefix, StdUnit_t type);
69     void setUnit(const MetricPrefix_t* prefixes, StdUnit_t type);
70     void copyUnitFrom(const Ref<Unit,Node>& src);
71     };
72     typedef Ref<Unit,Node> UnitRef;
73    
74     class ScalarNumberExpr : virtual public Unit, virtual public VMScalarNumberExpr, virtual public Expression {
75     public:
76     };
77     typedef Ref<ScalarNumberExpr,Node> ScalarNumberExprRef;
78    
79     class IntExpr : virtual public ScalarNumberExpr, virtual public VMIntExpr {
80     public:
81 schoenebeck 3557 ExprType_t exprType() const OVERRIDE { return INT_EXPR; }
82     String evalCastToStr() OVERRIDE;
83 schoenebeck 2581 };
84     typedef Ref<IntExpr,Node> IntExprRef;
85    
86 schoenebeck 3573 class RealExpr : virtual public ScalarNumberExpr, virtual public VMRealExpr {
87 schoenebeck 3056 public:
88 schoenebeck 3573 ExprType_t exprType() const OVERRIDE { return REAL_EXPR; }
89     String evalCastToStr() OVERRIDE;
90     };
91     typedef Ref<RealExpr,Node> RealExprRef;
92    
93     class ArrayExpr : virtual public VMArrayExpr, virtual public Expression {
94     public:
95     };
96     typedef Ref<ArrayExpr,Node> ArrayExprRef;
97    
98     class IntArrayExpr : virtual public VMIntArrayExpr, virtual public ArrayExpr {
99     public:
100 schoenebeck 3557 ExprType_t exprType() const OVERRIDE { return INT_ARR_EXPR; }
101     String evalCastToStr() OVERRIDE;
102 schoenebeck 3056 };
103 schoenebeck 3293 typedef Ref<IntArrayExpr,Node> IntArrayExprRef;
104 schoenebeck 3056
105 schoenebeck 3573 class RealArrayExpr : virtual public VMRealArrayExpr, virtual public ArrayExpr {
106     public:
107     ExprType_t exprType() const OVERRIDE { return REAL_ARR_EXPR; }
108     String evalCastToStr() OVERRIDE;
109     };
110     typedef Ref<RealArrayExpr,Node> RealArrayExprRef;
111    
112 schoenebeck 2581 class StringExpr : virtual public VMStringExpr, virtual public Expression {
113     public:
114 schoenebeck 3557 ExprType_t exprType() const OVERRIDE { return STRING_EXPR; }
115     String evalCastToStr() OVERRIDE { return evalStr(); }
116 schoenebeck 2581 };
117     typedef Ref<StringExpr,Node> StringExprRef;
118    
119 schoenebeck 3574 class IntLiteral FINAL : public IntExpr {
120 schoenebeck 3561 bool finalVal;
121     public:
122 schoenebeck 3557 vmint value;
123 schoenebeck 3573 IntLiteral(vmint value) : IntExpr(),
124 schoenebeck 3561 value(value), finalVal(false) { }
125 schoenebeck 3557 vmint evalInt() OVERRIDE;
126     void dump(int level = 0) OVERRIDE;
127     bool isConstExpr() const OVERRIDE { return true; }
128     bool isPolyphonic() const OVERRIDE { return false; }
129 schoenebeck 3561 bool isFinal() const OVERRIDE { return finalVal; }
130     void setFinal(bool b = true) { finalVal = b; }
131 schoenebeck 2581 };
132     typedef Ref<IntLiteral,Node> IntLiteralRef;
133    
134 schoenebeck 3574 class RealLiteral FINAL : public RealExpr {
135 schoenebeck 3573 bool finalVal;
136     public:
137 schoenebeck 3575 vmfloat value;
138 schoenebeck 3573 RealLiteral(vmfloat value) : RealExpr(),
139     value(value), finalVal(false) { }
140     vmfloat evalReal() OVERRIDE;
141     void dump(int level = 0) OVERRIDE;
142     bool isConstExpr() const OVERRIDE { return true; }
143     bool isPolyphonic() const OVERRIDE { return false; }
144     bool isFinal() const OVERRIDE { return finalVal; }
145     void setFinal(bool b = true) { finalVal = b; }
146     };
147     typedef Ref<RealLiteral,Node> RealLiteralRef;
148    
149 schoenebeck 3574 class StringLiteral FINAL : public StringExpr {
150 schoenebeck 2581 public:
151     String value;
152     StringLiteral(const String& value) : value(value) { }
153 schoenebeck 3557 bool isConstExpr() const OVERRIDE { return true; }
154     void dump(int level = 0) OVERRIDE;
155     String evalStr() OVERRIDE { return value; }
156     bool isPolyphonic() const OVERRIDE { return false; }
157 schoenebeck 2581 };
158     typedef Ref<StringLiteral,Node> StringLiteralRef;
159    
160 schoenebeck 3574 class Args FINAL : virtual public VMFnArgs, virtual public Node {
161 schoenebeck 2581 public:
162     std::vector<ExpressionRef> args;
163     void add(ExpressionRef arg) { args.push_back(arg); }
164 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
165     vmint argsCount() const OVERRIDE { return (vmint) args.size(); }
166     VMExpr* arg(vmint i) OVERRIDE { return (i >= 0 && i < argsCount()) ? &*args.at(i) : NULL; }
167     bool isPolyphonic() const OVERRIDE;
168 schoenebeck 2581 };
169     typedef Ref<Args,Node> ArgsRef;
170    
171 schoenebeck 2945 class Variable : virtual public VMVariable, virtual public Expression {
172 schoenebeck 2581 public:
173 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return bConst; }
174     bool isAssignable() const OVERRIDE { return !bConst; }
175 schoenebeck 2581 virtual void assign(Expression* expr) = 0;
176 schoenebeck 2945 void assignExpr(VMExpr* expr) OVERRIDE { Expression* e = dynamic_cast<Expression*>(expr); if (e) assign(e); }
177 schoenebeck 2581 protected:
178 schoenebeck 3557 Variable(ParserContext* ctx, vmint _memPos, bool _bConst)
179 schoenebeck 2581 : context(ctx), memPos(_memPos), bConst(_bConst) {}
180    
181     ParserContext* context;
182 schoenebeck 3557 vmint memPos;
183 schoenebeck 2581 bool bConst;
184     };
185     typedef Ref<Variable,Node> VariableRef;
186    
187 schoenebeck 3573 class ScalarNumberVariable : public Variable, virtual public ScalarNumberExpr {
188 schoenebeck 2581 bool polyphonic;
189 schoenebeck 3561 bool finalVal;
190 schoenebeck 2581 public:
191 schoenebeck 3573 bool isPolyphonic() const OVERRIDE { return polyphonic; }
192     bool isFinal() const OVERRIDE { return finalVal; }
193     void setFinal(bool b = true) { finalVal = b; }
194     protected:
195     ScalarNumberVariable(ParserContext* ctx, vmint _memPos,
196     bool _bConst = false, bool _bPolyphonic = false,
197     bool _bFinal = false);
198     };
199     typedef Ref<ScalarNumberVariable,Node> ScalarNumberVariableRef;
200    
201     class IntVariable : public ScalarNumberVariable, virtual public IntExpr {
202     public:
203 schoenebeck 2581 IntVariable(ParserContext* ctx);
204 schoenebeck 3557 void assign(Expression* expr) OVERRIDE;
205     vmint evalInt() OVERRIDE;
206     void dump(int level = 0) OVERRIDE;
207 schoenebeck 2581 protected:
208 schoenebeck 3557 IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, vmint size = 1);
209 schoenebeck 2581 };
210     typedef Ref<IntVariable,Node> IntVariableRef;
211    
212 schoenebeck 3573 class RealVariable : public ScalarNumberVariable, virtual public RealExpr {
213     public:
214     RealVariable(ParserContext* ctx);
215     void assign(Expression* expr) OVERRIDE;
216     vmfloat evalReal() OVERRIDE;
217     void dump(int level = 0) OVERRIDE;
218     protected:
219     RealVariable(ParserContext* ctx, bool polyphonic, bool bConst, vmint size = 1);
220     };
221     typedef Ref<RealVariable,Node> RealVariableRef;
222    
223 schoenebeck 3574 class ConstIntVariable FINAL : public IntVariable {
224 schoenebeck 2581 public:
225 schoenebeck 3557 vmint value;
226 schoenebeck 2581
227 schoenebeck 3557 ConstIntVariable(vmint value);
228     void assign(Expression* expr) OVERRIDE;
229     vmint evalInt() OVERRIDE;
230     void dump(int level = 0) OVERRIDE;
231 schoenebeck 2581 };
232     typedef Ref<ConstIntVariable,Node> ConstIntVariableRef;
233    
234 schoenebeck 3574 class ConstRealVariable FINAL : public RealVariable {
235 schoenebeck 3573 public:
236     vmfloat value;
237    
238     ConstRealVariable(vmfloat value);
239     void assign(Expression* expr) OVERRIDE;
240     vmfloat evalReal() OVERRIDE;
241     void dump(int level = 0) OVERRIDE;
242     };
243     typedef Ref<ConstRealVariable,Node> ConstRealVariableRef;
244    
245 schoenebeck 3574 class BuiltInIntVariable FINAL : public IntVariable {
246 schoenebeck 2594 String name;
247 schoenebeck 3557 VMIntPtr* ptr;
248 schoenebeck 2594 public:
249 schoenebeck 3557 BuiltInIntVariable(const String& name, VMIntPtr* ptr);
250     bool isAssignable() const OVERRIDE { return ptr->isAssignable(); }
251 schoenebeck 3054 void assign(Expression* expr) OVERRIDE;
252 schoenebeck 3557 vmint evalInt() OVERRIDE;
253 schoenebeck 3054 void dump(int level = 0) OVERRIDE;
254 schoenebeck 2594 };
255     typedef Ref<BuiltInIntVariable,Node> BuiltInIntVariableRef;
256    
257 schoenebeck 3574 class PolyphonicIntVariable FINAL : public IntVariable {
258 schoenebeck 2581 public:
259     PolyphonicIntVariable(ParserContext* ctx);
260 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
261 schoenebeck 2581 };
262     typedef Ref<PolyphonicIntVariable,Node> PolyphonicIntVariableRef;
263    
264 schoenebeck 3574 class PolyphonicRealVariable FINAL : public RealVariable {
265 schoenebeck 3573 public:
266     PolyphonicRealVariable(ParserContext* ctx);
267     void dump(int level = 0) OVERRIDE;
268     };
269     typedef Ref<PolyphonicRealVariable,Node> PolyphonicRealVariableRef;
270    
271 schoenebeck 3293 class IntArrayVariable : public Variable, virtual public IntArrayExpr {
272 schoenebeck 3557 ArrayList<vmint> values;
273 schoenebeck 2581 public:
274 schoenebeck 3557 IntArrayVariable(ParserContext* ctx, vmint size);
275     IntArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst = false);
276     void assign(Expression* expr) OVERRIDE {} // ignore scalar assignment
277     String evalCastToStr() OVERRIDE { return ""; } // ignore scalar cast to string
278     ExprType_t exprType() const OVERRIDE { return INT_ARR_EXPR; }
279     virtual vmint arraySize() const OVERRIDE { return values.size(); }
280     virtual vmint evalIntElement(vmuint i) OVERRIDE;
281     virtual void assignIntElement(vmuint i, vmint value) OVERRIDE;
282     void dump(int level = 0) OVERRIDE;
283     bool isPolyphonic() const OVERRIDE { return false; }
284 schoenebeck 2594 protected:
285     IntArrayVariable(ParserContext* ctx, bool bConst);
286     };
287     typedef Ref<IntArrayVariable,Node> IntArrayVariableRef;
288    
289 schoenebeck 3574 class RealArrayVariable FINAL : public Variable, virtual public RealArrayExpr {
290 schoenebeck 3573 ArrayList<vmfloat> values;
291     public:
292     RealArrayVariable(ParserContext* ctx, vmint size);
293     RealArrayVariable(ParserContext* ctx, vmint size, ArgsRef values, bool _bConst = false);
294     void assign(Expression* expr) OVERRIDE {} // ignore scalar assignment
295     String evalCastToStr() OVERRIDE { return ""; } // ignore scalar cast to string
296     ExprType_t exprType() const OVERRIDE { return REAL_ARR_EXPR; }
297     virtual vmint arraySize() const OVERRIDE { return values.size(); }
298     virtual vmfloat evalRealElement(vmuint i) OVERRIDE;
299     virtual void assignRealElement(vmuint i, vmfloat value) OVERRIDE;
300     void dump(int level = 0) OVERRIDE;
301     bool isPolyphonic() const OVERRIDE { return false; }
302     protected:
303     RealArrayVariable(ParserContext* ctx, bool bConst);
304     };
305     typedef Ref<RealArrayVariable,Node> RealArrayVariableRef;
306    
307 schoenebeck 3574 class BuiltInIntArrayVariable FINAL : public IntArrayVariable {
308 schoenebeck 2594 String name;
309     VMInt8Array* array;
310     public:
311     BuiltInIntArrayVariable(const String& name, VMInt8Array* array);
312 schoenebeck 3557 vmint arraySize() const OVERRIDE { return array->size; }
313     vmint evalIntElement(vmuint i) OVERRIDE;
314 schoenebeck 3253 bool isAssignable() const OVERRIDE { return !array->readonly; }
315 schoenebeck 3557 void assignIntElement(vmuint i, vmint value) OVERRIDE;
316 persson 3455 void dump(int level = 0) OVERRIDE;
317 schoenebeck 2581 };
318 schoenebeck 2594 typedef Ref<BuiltInIntArrayVariable,Node> BuiltInIntArrayVariableRef;
319 schoenebeck 2581
320 schoenebeck 3574 class IntArrayElement FINAL : public IntVariable {
321 schoenebeck 3293 IntArrayExprRef array;
322 schoenebeck 2581 IntExprRef index;
323     public:
324 schoenebeck 3293 IntArrayElement(IntArrayExprRef array, IntExprRef arrayIndex);
325 schoenebeck 3557 void assign(Expression* expr) OVERRIDE;
326     vmint evalInt() OVERRIDE;
327     void dump(int level = 0) OVERRIDE;
328 schoenebeck 2581 };
329     typedef Ref<IntArrayElement,Node> IntArrayElementRef;
330    
331 schoenebeck 3574 class RealArrayElement FINAL : public RealVariable {
332 schoenebeck 3573 RealArrayExprRef array;
333     IntExprRef index;
334     public:
335     RealArrayElement(RealArrayExprRef array, IntExprRef arrayIndex);
336     void assign(Expression* expr) OVERRIDE;
337     vmfloat evalReal() OVERRIDE;
338     void dump(int level = 0) OVERRIDE;
339     };
340     typedef Ref<RealArrayElement,Node> RealArrayElementRef;
341    
342 schoenebeck 2581 class StringVariable : public Variable, virtual public StringExpr {
343     public:
344     StringVariable(ParserContext* ctx);
345 schoenebeck 3557 void assign(Expression* expr) OVERRIDE;
346     String evalStr() OVERRIDE;
347     void dump(int level = 0) OVERRIDE;
348     bool isPolyphonic() const OVERRIDE { return false; }
349 schoenebeck 2581 protected:
350     StringVariable(ParserContext* ctx, bool bConst);
351     };
352     typedef Ref<StringVariable,Node> StringVariableRef;
353    
354 schoenebeck 3574 class ConstStringVariable FINAL : public StringVariable {
355 schoenebeck 2581 public:
356     String value;
357    
358     ConstStringVariable(ParserContext* ctx, String value = "");
359 schoenebeck 3557 void assign(Expression* expr) OVERRIDE;
360     String evalStr() OVERRIDE;
361     void dump(int level = 0) OVERRIDE;
362 schoenebeck 2581 };
363     typedef Ref<ConstStringVariable,Node> ConstStringVariableRef;
364    
365     class BinaryOp : virtual public Expression {
366     protected:
367     ExpressionRef lhs;
368     ExpressionRef rhs;
369     public:
370     BinaryOp(ExpressionRef lhs, ExpressionRef rhs) : lhs(lhs), rhs(rhs) { }
371 schoenebeck 3557 bool isConstExpr() const OVERRIDE { return lhs->isConstExpr() && rhs->isConstExpr(); }
372     bool isPolyphonic() const OVERRIDE { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
373 schoenebeck 2581 };
374     typedef Ref<BinaryOp,Node> BinaryOpRef;
375    
376 schoenebeck 3573 class ScalarNumberBinaryOp : public BinaryOp, virtual public ScalarNumberExpr {
377 schoenebeck 2581 public:
378 schoenebeck 3573 ScalarNumberBinaryOp(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : BinaryOp(lhs, rhs) { }
379 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE;
380     StdUnit_t unitType() const OVERRIDE;
381     bool isFinal() const OVERRIDE;
382     };
383 schoenebeck 3573 typedef Ref<ScalarNumberBinaryOp,Node> ScalarNumberBinaryOpRef;
384    
385     class IntBinaryOp : public ScalarNumberBinaryOp, virtual public IntExpr {
386     public:
387     IntBinaryOp(IntExprRef lhs, IntExprRef rhs) : ScalarNumberBinaryOp(lhs, rhs) { }
388     };
389 schoenebeck 3561 typedef Ref<IntBinaryOp,Node> IntBinaryOpRef;
390    
391 schoenebeck 3573 class VaritypeScalarBinaryOp : public ScalarNumberBinaryOp, virtual public IntExpr, virtual public RealExpr {
392 schoenebeck 3561 public:
393 schoenebeck 3573 VaritypeScalarBinaryOp(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : ScalarNumberBinaryOp(lhs, rhs) { }
394     ExprType_t exprType() const OVERRIDE;
395     String evalCastToStr() OVERRIDE;
396     };
397     typedef Ref<VaritypeScalarBinaryOp,Node> VaritypeScalarBinaryOpRef;
398    
399 schoenebeck 3574 class Add FINAL : public VaritypeScalarBinaryOp {
400 schoenebeck 3573 public:
401     Add(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
402 schoenebeck 3557 vmint evalInt() OVERRIDE;
403 schoenebeck 3573 vmfloat evalReal() OVERRIDE;
404 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
405 schoenebeck 2581 };
406     typedef Ref<Add,Node> AddRef;
407    
408 schoenebeck 3574 class Sub FINAL : public VaritypeScalarBinaryOp {
409 schoenebeck 2581 public:
410 schoenebeck 3573 Sub(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
411 schoenebeck 3557 vmint evalInt() OVERRIDE;
412 schoenebeck 3573 vmfloat evalReal() OVERRIDE;
413 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
414 schoenebeck 2581 };
415     typedef Ref<Sub,Node> SubRef;
416    
417 schoenebeck 3574 class Mul FINAL : public VaritypeScalarBinaryOp {
418 schoenebeck 2581 public:
419 schoenebeck 3573 Mul(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
420 schoenebeck 3557 vmint evalInt() OVERRIDE;
421 schoenebeck 3573 vmfloat evalReal() OVERRIDE;
422 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
423 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE;
424     StdUnit_t unitType() const OVERRIDE;
425 schoenebeck 2581 };
426     typedef Ref<Mul,Node> MulRef;
427    
428 schoenebeck 3574 class Div FINAL : public VaritypeScalarBinaryOp {
429 schoenebeck 2581 public:
430 schoenebeck 3573 Div(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
431 schoenebeck 3557 vmint evalInt() OVERRIDE;
432 schoenebeck 3573 vmfloat evalReal() OVERRIDE;
433 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
434 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE;
435     StdUnit_t unitType() const OVERRIDE;
436 schoenebeck 2581 };
437     typedef Ref<Div,Node> DivRef;
438    
439 schoenebeck 3574 class Mod FINAL : public IntBinaryOp {
440 schoenebeck 2581 public:
441 schoenebeck 3561 Mod(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs, rhs) { }
442 schoenebeck 3557 vmint evalInt() OVERRIDE;
443     void dump(int level = 0) OVERRIDE;
444 schoenebeck 2581 };
445     typedef Ref<Mod,Node> ModRef;
446    
447     class Statement : virtual public Node {
448     public:
449     virtual StmtType_t statementType() const = 0;
450     };
451     typedef Ref<Statement,Node> StatementRef;
452    
453     // Just used by parser to avoid "not a statement" parser warning, will be
454     // filtered out by parser. So it will not be part of the VM tree after parsing.
455 schoenebeck 3574 class NoOperation FINAL : public Statement {
456 schoenebeck 2581 public:
457     NoOperation() : Statement() {}
458 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }
459     void dump(int level = 0) OVERRIDE {}
460     bool isPolyphonic() const OVERRIDE { return false; }
461 schoenebeck 2581 };
462     typedef Ref<NoOperation,Node> NoOperationRef;
463    
464     bool isNoOperation(StatementRef statement);
465    
466     class LeafStatement : public Statement {
467     public:
468     virtual StmtFlags_t exec() = 0;
469 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_LEAF; }
470 schoenebeck 2581 };
471     typedef Ref<LeafStatement,Node> LeafStatementRef;
472    
473     class Statements : public Statement {
474     std::vector<StatementRef> args;
475     public:
476     void add(StatementRef arg) { args.push_back(arg); }
477 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
478     StmtType_t statementType() const OVERRIDE { return STMT_LIST; }
479 schoenebeck 2581 virtual Statement* statement(uint i);
480 schoenebeck 3557 bool isPolyphonic() const OVERRIDE;
481 schoenebeck 2581 };
482     typedef Ref<Statements,Node> StatementsRef;
483    
484     class BranchStatement : public Statement {
485     public:
486 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_BRANCH; }
487     virtual vmint evalBranch() = 0;
488     virtual Statements* branch(vmuint i) const = 0;
489 schoenebeck 2581 };
490    
491 schoenebeck 3574 class DynamicVariableCall FINAL : public Variable, virtual public IntExpr, virtual public StringExpr, virtual public IntArrayExpr {
492 schoenebeck 2942 VMDynVar* dynVar;
493     String varName;
494     public:
495     DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v);
496     ExprType_t exprType() const OVERRIDE { return dynVar->exprType(); }
497     bool isConstExpr() const OVERRIDE { return dynVar->isConstExpr(); }
498     bool isAssignable() const OVERRIDE { return dynVar->isAssignable(); }
499     bool isPolyphonic() const OVERRIDE { return false; }
500 schoenebeck 2945 void assign(Expression* expr) OVERRIDE { dynVar->assignExpr(expr); }
501 schoenebeck 3118 VMIntArrayExpr* asIntArray() const OVERRIDE { return dynVar->asIntArray(); }
502 schoenebeck 3557 vmint evalInt() OVERRIDE;
503 schoenebeck 2942 String evalStr() OVERRIDE;
504     String evalCastToStr() OVERRIDE;
505 schoenebeck 3557 vmint arraySize() const OVERRIDE { return dynVar->asIntArray()->arraySize(); }
506     vmint evalIntElement(vmuint i) OVERRIDE { return dynVar->asIntArray()->evalIntElement(i); }
507     void assignIntElement(vmuint i, vmint value) OVERRIDE { return dynVar->asIntArray()->assignIntElement(i, value); }
508 schoenebeck 2942 void dump(int level = 0) OVERRIDE;
509 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
510     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
511     bool isFinal() const OVERRIDE { return false; }
512 schoenebeck 2942 };
513     typedef Ref<DynamicVariableCall,Node> DynamicVariableCallRef;
514    
515 schoenebeck 3573 class FunctionCall : virtual public LeafStatement, virtual public IntExpr, virtual public RealExpr, virtual public StringExpr {
516 schoenebeck 2581 String functionName;
517     ArgsRef args;
518     VMFunction* fn;
519     public:
520     FunctionCall(const char* function, ArgsRef args, VMFunction* fn) :
521     functionName(function), args(args), fn(fn) { }
522 schoenebeck 3060 void dump(int level = 0) OVERRIDE;
523     StmtFlags_t exec() OVERRIDE;
524 schoenebeck 3557 vmint evalInt() OVERRIDE;
525 schoenebeck 3573 vmfloat evalReal() OVERRIDE;
526 schoenebeck 3056 VMIntArrayExpr* asIntArray() const OVERRIDE;
527 schoenebeck 3573 VMRealArrayExpr* asRealArray() const OVERRIDE;
528 schoenebeck 3060 String evalStr() OVERRIDE;
529     bool isConstExpr() const OVERRIDE { return false; }
530     ExprType_t exprType() const OVERRIDE;
531     String evalCastToStr() OVERRIDE;
532     bool isPolyphonic() const OVERRIDE { return args->isPolyphonic(); }
533 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
534     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
535     bool isFinal() const OVERRIDE { return false; }
536 schoenebeck 2581 protected:
537     VMFnResult* execVMFn();
538     };
539     typedef Ref<FunctionCall,Node> FunctionCallRef;
540    
541 schoenebeck 3574 class NoFunctionCall FINAL : public FunctionCall {
542 schoenebeck 3311 public:
543     NoFunctionCall() : FunctionCall("nothing", new Args, NULL) {}
544 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }
545 schoenebeck 3311 };
546     typedef Ref<NoFunctionCall,Node> NoFunctionCallRef;
547    
548 schoenebeck 2581 class EventHandler : virtual public Statements, virtual public VMEventHandler {
549     StatementsRef statements;
550 schoenebeck 2645 bool usingPolyphonics;
551 schoenebeck 2581 public:
552 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
553 schoenebeck 2581 StmtFlags_t exec();
554 schoenebeck 2645 EventHandler(StatementsRef statements);
555 schoenebeck 3557 Statement* statement(uint i) OVERRIDE { return statements->statement(i); }
556     bool isPolyphonic() const OVERRIDE { return usingPolyphonics; }
557 schoenebeck 2581 };
558     typedef Ref<EventHandler,Node> EventHandlerRef;
559    
560 schoenebeck 3574 class OnNote FINAL : public EventHandler {
561 schoenebeck 2581 public:
562     OnNote(StatementsRef statements) : EventHandler(statements) {}
563 schoenebeck 3557 VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_NOTE; }
564     String eventHandlerName() const OVERRIDE { return "note"; }
565 schoenebeck 2581 };
566     typedef Ref<OnNote,Node> OnNoteRef;
567    
568 schoenebeck 3574 class OnInit FINAL : public EventHandler {
569 schoenebeck 2581 public:
570     OnInit(StatementsRef statements) : EventHandler(statements) {}
571 schoenebeck 3557 VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_INIT; }
572     String eventHandlerName() const OVERRIDE { return "init"; }
573 schoenebeck 2581 };
574     typedef Ref<OnInit,Node> OnInitRef;
575    
576 schoenebeck 3574 class OnRelease FINAL : public EventHandler {
577 schoenebeck 2581 public:
578     OnRelease(StatementsRef statements) : EventHandler(statements) {}
579 schoenebeck 3557 VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_RELEASE; }
580     String eventHandlerName() const OVERRIDE { return "release"; }
581 schoenebeck 2581 };
582     typedef Ref<OnRelease,Node> OnReleaseRef;
583    
584 schoenebeck 3574 class OnController FINAL : public EventHandler {
585 schoenebeck 2581 public:
586     OnController(StatementsRef statements) : EventHandler(statements) {}
587 schoenebeck 3557 VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_CONTROLLER; }
588     String eventHandlerName() const OVERRIDE { return "controller"; }
589 schoenebeck 2581 };
590     typedef Ref<OnController,Node> OnControllerRef;
591    
592 schoenebeck 3574 class EventHandlers FINAL : virtual public Node {
593 schoenebeck 2581 std::vector<EventHandlerRef> args;
594     public:
595     EventHandlers();
596     ~EventHandlers();
597     void add(EventHandlerRef arg);
598 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
599 schoenebeck 2581 EventHandler* eventHandlerByName(const String& name) const;
600     EventHandler* eventHandler(uint index) const;
601 schoenebeck 3054 inline uint size() const { return (int) args.size(); }
602 schoenebeck 3557 bool isPolyphonic() const OVERRIDE;
603 schoenebeck 2581 };
604     typedef Ref<EventHandlers,Node> EventHandlersRef;
605    
606 schoenebeck 3574 class Assignment FINAL : public LeafStatement {
607 schoenebeck 2581 protected:
608     VariableRef variable;
609     ExpressionRef value;
610     public:
611     Assignment(VariableRef variable, ExpressionRef value);
612 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
613     StmtFlags_t exec() OVERRIDE;
614     bool isPolyphonic() const OVERRIDE { return (variable && variable->isPolyphonic()) || (value && value->isPolyphonic()); }
615 schoenebeck 2581 };
616     typedef Ref<Assignment,Node> AssignmentRef;
617    
618 schoenebeck 3574 class If FINAL : public BranchStatement {
619 schoenebeck 2581 IntExprRef condition;
620     StatementsRef ifStatements;
621     StatementsRef elseStatements;
622     public:
623     If(IntExprRef condition, StatementsRef ifStatements, StatementsRef elseStatements) :
624     condition(condition), ifStatements(ifStatements), elseStatements(elseStatements) { }
625     If(IntExprRef condition, StatementsRef statements) :
626     condition(condition), ifStatements(statements) { }
627 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
628     vmint evalBranch() OVERRIDE;
629     Statements* branch(vmuint i) const OVERRIDE;
630     bool isPolyphonic() const OVERRIDE;
631 schoenebeck 2581 };
632     typedef Ref<If,Node> IfRef;
633    
634 schoenebeck 3574 struct CaseBranch FINAL {
635 schoenebeck 2581 IntExprRef from;
636     IntExprRef to;
637     StatementsRef statements;
638     };
639     typedef std::vector<CaseBranch> CaseBranches;
640    
641 schoenebeck 3574 class SelectCase FINAL : public BranchStatement {
642 schoenebeck 2581 IntExprRef select;
643     CaseBranches branches;
644     public:
645     SelectCase(IntExprRef select, const CaseBranches& branches) : select(select), branches(branches) { }
646 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
647     vmint evalBranch() OVERRIDE;
648     Statements* branch(vmuint i) const OVERRIDE;
649 schoenebeck 2581 //void addBranch(IntExprRef condition, StatementsRef statements);
650     //void addBranch(IntExprRef from, IntExprRef to, StatementsRef statements);
651     //void addBranch(CaseBranchRef branch);
652     //void addBranches(CaseBranchesRef branches);
653 schoenebeck 3557 bool isPolyphonic() const OVERRIDE;
654 schoenebeck 2581 };
655     typedef Ref<SelectCase,Node> SelectCaseRef;
656    
657 schoenebeck 3574 class While FINAL : public Statement {
658 schoenebeck 2581 IntExprRef m_condition;
659     StatementsRef m_statements;
660     public:
661     While(IntExprRef condition, StatementsRef statements) :
662     m_condition(condition), m_statements(statements) {}
663 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_LOOP; }
664     void dump(int level = 0) OVERRIDE;
665 schoenebeck 2581 bool evalLoopStartCondition();
666     Statements* statements() const;
667 schoenebeck 3557 bool isPolyphonic() const OVERRIDE { return m_condition->isPolyphonic() || m_statements->isPolyphonic(); }
668 schoenebeck 2581 };
669    
670 schoenebeck 3574 class SyncBlock FINAL : public Statement {
671 schoenebeck 3260 StatementsRef m_statements;
672     public:
673     SyncBlock(StatementsRef statements) : m_statements(statements) {}
674 schoenebeck 3557 StmtType_t statementType() const OVERRIDE { return STMT_SYNC; }
675     void dump(int level = 0) OVERRIDE;
676 schoenebeck 3260 Statements* statements() const;
677 schoenebeck 3557 bool isPolyphonic() const OVERRIDE { return m_statements->isPolyphonic(); }
678 schoenebeck 3260 };
679     typedef Ref<SyncBlock,Node> SyncBlockRef;
680    
681 schoenebeck 3576 class Neg FINAL : virtual public IntExpr, virtual public RealExpr {
682     ScalarNumberExprRef expr;
683 schoenebeck 2581 public:
684 schoenebeck 3576 Neg(ScalarNumberExprRef expr) : expr(expr) { }
685     ExprType_t exprType() const OVERRIDE { return expr->exprType(); }
686     vmint evalInt() OVERRIDE { return (expr) ? -(expr->asInt()->evalInt()) : 0; }
687     vmfloat evalReal() OVERRIDE { return (expr) ? -(expr->asReal()->evalReal()) : vmfloat(0); }
688     String evalCastToStr() OVERRIDE;
689 schoenebeck 3557 void dump(int level = 0) OVERRIDE;
690     bool isConstExpr() const OVERRIDE { return expr->isConstExpr(); }
691     bool isPolyphonic() const OVERRIDE { return expr->isPolyphonic(); }
692 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return expr->unitPrefix(i); }
693     StdUnit_t unitType() const OVERRIDE { return expr->unitType(); }
694     bool isFinal() const OVERRIDE { return expr->isFinal(); }
695 schoenebeck 2581 };
696     typedef Ref<Neg,Node> NegRef;
697    
698 schoenebeck 3574 class ConcatString FINAL : public StringExpr {
699 schoenebeck 2581 ExpressionRef lhs;
700     ExpressionRef rhs;
701     public:
702     ConcatString(ExpressionRef lhs, ExpressionRef rhs) : lhs(lhs), rhs(rhs) {}
703 schoenebeck 3557 String evalStr() OVERRIDE;
704     void dump(int level = 0) OVERRIDE;
705     bool isConstExpr() const OVERRIDE;
706     bool isPolyphonic() const OVERRIDE { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
707 schoenebeck 2581 };
708     typedef Ref<ConcatString,Node> ConcatStringRef;
709    
710 schoenebeck 3574 class Relation FINAL : public IntExpr {
711 schoenebeck 2581 public:
712     enum Type {
713     LESS_THAN,
714     GREATER_THAN,
715     LESS_OR_EQUAL,
716     GREATER_OR_EQUAL,
717     EQUAL,
718     NOT_EQUAL
719     };
720 schoenebeck 3573 Relation(ExpressionRef lhs, Type type, ExpressionRef rhs) :
721 schoenebeck 2581 lhs(lhs), rhs(rhs), type(type) {}
722 schoenebeck 3557 vmint evalInt() OVERRIDE;
723     void dump(int level = 0) OVERRIDE;
724     bool isConstExpr() const OVERRIDE;
725     bool isPolyphonic() const OVERRIDE { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
726 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
727     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
728     bool isFinal() const OVERRIDE { return false; }
729 schoenebeck 2581 private:
730 schoenebeck 3573 ExpressionRef lhs;
731     ExpressionRef rhs;
732 schoenebeck 2581 Type type;
733     };
734     typedef Ref<Relation,Node> RelationRef;
735    
736 schoenebeck 3574 class Or FINAL : public IntBinaryOp {
737 schoenebeck 2581 public:
738 schoenebeck 3561 Or(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
739 schoenebeck 3557 vmint evalInt() OVERRIDE;
740     void dump(int level = 0) OVERRIDE;
741 schoenebeck 2581 };
742     typedef Ref<Or,Node> OrRef;
743    
744 schoenebeck 3574 class BitwiseOr FINAL : public IntBinaryOp {
745 schoenebeck 2935 public:
746 schoenebeck 3561 BitwiseOr(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
747 schoenebeck 3557 vmint evalInt() OVERRIDE;
748     void dump(int level = 0) OVERRIDE;
749 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
750     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
751 schoenebeck 2935 };
752     typedef Ref<BitwiseOr,Node> BitwiseOrRef;
753    
754 schoenebeck 3574 class And FINAL : public IntBinaryOp {
755 schoenebeck 2581 public:
756 schoenebeck 3561 And(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
757 schoenebeck 3557 vmint evalInt() OVERRIDE;
758     void dump(int level = 0) OVERRIDE;
759 schoenebeck 2581 };
760     typedef Ref<And,Node> AndRef;
761    
762 schoenebeck 3574 class BitwiseAnd FINAL : public IntBinaryOp {
763 schoenebeck 2935 public:
764 schoenebeck 3561 BitwiseAnd(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
765 schoenebeck 3557 vmint evalInt() OVERRIDE;
766     void dump(int level = 0) OVERRIDE;
767 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
768     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
769 schoenebeck 2935 };
770     typedef Ref<BitwiseAnd,Node> BitwiseAndRef;
771    
772 schoenebeck 3574 class Not FINAL : virtual public IntExpr {
773 schoenebeck 2581 IntExprRef expr;
774     public:
775     Not(IntExprRef expr) : expr(expr) {}
776 schoenebeck 3557 vmint evalInt() OVERRIDE { return !expr->evalInt(); }
777     void dump(int level = 0) OVERRIDE;
778     bool isConstExpr() const OVERRIDE { return expr->isConstExpr(); }
779     bool isPolyphonic() const OVERRIDE { return expr->isPolyphonic(); }
780 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
781     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
782     bool isFinal() const OVERRIDE { return expr->isFinal(); }
783 schoenebeck 2581 };
784     typedef Ref<Not,Node> NotRef;
785    
786 schoenebeck 3574 class BitwiseNot FINAL : virtual public IntExpr {
787 schoenebeck 2935 IntExprRef expr;
788     public:
789     BitwiseNot(IntExprRef expr) : expr(expr) {}
790 schoenebeck 3557 vmint evalInt() OVERRIDE { return ~expr->evalInt(); }
791     void dump(int level = 0) OVERRIDE;
792     bool isConstExpr() const OVERRIDE { return expr->isConstExpr(); }
793     bool isPolyphonic() const OVERRIDE { return expr->isPolyphonic(); }
794 schoenebeck 3561 MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return VM_NO_PREFIX; }
795     StdUnit_t unitType() const OVERRIDE { return VM_NO_UNIT; }
796     bool isFinal() const OVERRIDE { return expr->isFinal(); }
797 schoenebeck 2935 };
798     typedef Ref<BitwiseNot,Node> BitwiseNotRef;
799    
800 schoenebeck 3574 class Final FINAL : virtual public IntExpr, virtual public RealExpr {
801 schoenebeck 3573 ScalarNumberExprRef expr;
802 schoenebeck 3561 public:
803 schoenebeck 3573 Final(ScalarNumberExprRef expr) : expr(expr) {}
804     ExprType_t exprType() const OVERRIDE { return expr->exprType(); }
805     vmint evalInt() OVERRIDE { return expr->asInt()->evalInt(); }
806     vmfloat evalReal() OVERRIDE { return expr->asReal()->evalReal(); }
807     String evalCastToStr() OVERRIDE;
808 schoenebeck 3561 void dump(int level = 0) OVERRIDE;
809     bool isConstExpr() const OVERRIDE { return expr->isConstExpr(); }
810     bool isPolyphonic() const OVERRIDE { return expr->isPolyphonic(); }
811     MetricPrefix_t unitPrefix(vmuint i) const OVERRIDE { return expr->unitPrefix(i); }
812     StdUnit_t unitType() const OVERRIDE { return expr->unitType(); }
813     bool isFinal() const OVERRIDE { return true; }
814     };
815     typedef Ref<Final,Node> FinalRef;
816    
817 schoenebeck 3574 class ParserContext FINAL : public VMParserContext {
818 schoenebeck 2581 public:
819     struct Error {
820     String txt;
821     int line;
822     };
823     typedef Error Warning;
824    
825     void* scanner;
826     std::istream* is;
827 schoenebeck 2588 std::vector<ParserIssue> vErrors;
828     std::vector<ParserIssue> vWarnings;
829     std::vector<ParserIssue> vIssues;
830 schoenebeck 3285 std::vector<CodeBlock> vPreprocessorComments;
831 schoenebeck 2581
832     std::set<String> builtinPreprocessorConditions;
833     std::set<String> userPreprocessorConditions;
834    
835     std::map<String,VariableRef> vartable;
836 schoenebeck 2951 std::map<String,StatementsRef> userFnTable;
837 schoenebeck 3557 vmint globalIntVarCount;
838 schoenebeck 3573 vmint globalRealVarCount;
839 schoenebeck 3557 vmint globalStrVarCount;
840     vmint polyphonicIntVarCount;
841 schoenebeck 3573 vmint polyphonicRealVarCount;
842 schoenebeck 2581
843     EventHandlersRef handlers;
844    
845     OnInitRef onInit;
846     OnNoteRef onNote;
847     OnReleaseRef onRelease;
848     OnControllerRef onController;
849    
850 schoenebeck 3557 ArrayList<vmint>* globalIntMemory;
851 schoenebeck 3573 ArrayList<vmfloat>* globalRealMemory;
852 schoenebeck 2581 ArrayList<String>* globalStrMemory;
853 schoenebeck 3557 vmint requiredMaxStackSize;
854 schoenebeck 2581
855     VMFunctionProvider* functionProvider;
856    
857     ExecContext* execContext;
858    
859     ParserContext(VMFunctionProvider* parent) :
860     scanner(NULL), is(NULL),
861 schoenebeck 3573 globalIntVarCount(0), globalRealVarCount(0), globalStrVarCount(0),
862     polyphonicIntVarCount(0), polyphonicRealVarCount(0),
863     globalIntMemory(NULL), globalRealMemory(NULL), globalStrMemory(NULL),
864     requiredMaxStackSize(-1),
865 schoenebeck 2588 functionProvider(parent), execContext(NULL)
866 schoenebeck 2581 {
867     }
868 schoenebeck 2588 virtual ~ParserContext();
869 schoenebeck 2581 VariableRef globalVar(const String& name);
870     IntVariableRef globalIntVar(const String& name);
871 schoenebeck 3573 RealVariableRef globalRealVar(const String& name);
872 schoenebeck 2581 StringVariableRef globalStrVar(const String& name);
873     VariableRef variableByName(const String& name);
874 schoenebeck 2951 StatementsRef userFunctionByName(const String& name);
875 schoenebeck 2889 void addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt);
876     void addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt);
877 schoenebeck 3285 void addPreprocessorComment(int firstLine, int lastLine, int firstColumn, int lastColumn);
878 schoenebeck 2581 void createScanner(std::istream* is);
879     void destroyScanner();
880     bool setPreprocessorCondition(const char* name);
881     bool resetPreprocessorCondition(const char* name);
882     bool isPreprocessorConditionSet(const char* name);
883 schoenebeck 2588 std::vector<ParserIssue> issues() const OVERRIDE;
884     std::vector<ParserIssue> errors() const OVERRIDE;
885     std::vector<ParserIssue> warnings() const OVERRIDE;
886 schoenebeck 3285 std::vector<CodeBlock> preprocessorComments() const OVERRIDE;
887 schoenebeck 2588 VMEventHandler* eventHandler(uint index) OVERRIDE;
888     VMEventHandler* eventHandlerByName(const String& name) OVERRIDE;
889 schoenebeck 3557 void registerBuiltInConstIntVariables(const std::map<String,vmint>& vars);
890     void registerBuiltInIntVariables(const std::map<String,VMIntPtr*>& vars);
891 schoenebeck 2594 void registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars);
892 schoenebeck 2942 void registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars);
893 schoenebeck 2581 };
894    
895 schoenebeck 3574 class ExecContext FINAL : public VMExecContext {
896 schoenebeck 2581 public:
897     struct StackFrame {
898     Statement* statement;
899     int subindex;
900    
901     StackFrame() {
902     statement = NULL;
903     subindex = -1;
904     }
905     };
906    
907 schoenebeck 3557 ArrayList<vmint> polyphonicIntMemory;
908 schoenebeck 3573 ArrayList<vmfloat> polyphonicRealMemory;
909 schoenebeck 2581 VMExecStatus_t status;
910 schoenebeck 3277 StmtFlags_t flags;
911 schoenebeck 2581 ArrayList<StackFrame> stack;
912     int stackFrame;
913 schoenebeck 3557 vmint suspendMicroseconds;
914 schoenebeck 3221 size_t instructionsCount;
915 schoenebeck 3551 struct ExitRes {
916     Expression* value;
917     IntLiteral intLiteral;
918 schoenebeck 3575 RealLiteral realLiteral;
919 schoenebeck 3551 StringLiteral stringLiteral;
920 schoenebeck 2581
921 schoenebeck 3575 ExitRes() : intLiteral(0), realLiteral(0.0), stringLiteral("") { }
922 schoenebeck 3551 } exitRes;
923 schoenebeck 2581
924 schoenebeck 3551 ExecContext();
925 schoenebeck 2581 virtual ~ExecContext() {}
926    
927     inline void pushStack(Statement* stmt) {
928     stackFrame++;
929     //printf("pushStack() -> %d\n", stackFrame);
930     if (stackFrame >= stack.size()) return;
931     stack[stackFrame].statement = stmt;
932     stack[stackFrame].subindex = 0;
933     }
934    
935     inline void popStack() {
936     stack[stackFrame].statement = NULL;
937     stack[stackFrame].subindex = -1;
938     stackFrame--;
939     //printf("popStack() -> %d\n", stackFrame);
940     }
941    
942     inline void reset() {
943     stack[0].statement = NULL;
944     stack[0].subindex = -1;
945     stackFrame = -1;
946 schoenebeck 3277 flags = STMT_SUCCESS;
947 schoenebeck 2581 }
948    
949 schoenebeck 3551 inline void clearExitRes() {
950     exitRes.value = NULL;
951     }
952    
953 schoenebeck 3557 vmint suspensionTimeMicroseconds() const OVERRIDE {
954 schoenebeck 2581 return suspendMicroseconds;
955     }
956 schoenebeck 3207
957     void resetPolyphonicData() OVERRIDE {
958 schoenebeck 3573 if (!polyphonicIntMemory.empty())
959     memset(&polyphonicIntMemory[0], 0, polyphonicIntMemory.size() * sizeof(vmint));
960     if (!polyphonicRealMemory.empty())
961     memset(&polyphonicRealMemory[0], 0, polyphonicRealMemory.size() * sizeof(vmfloat));
962 schoenebeck 3207 }
963 schoenebeck 3221
964     size_t instructionsPerformed() const OVERRIDE {
965     return instructionsCount;
966     }
967 schoenebeck 3277
968     void signalAbort() OVERRIDE {
969     flags = StmtFlags_t(flags | STMT_ABORT_SIGNALLED);
970     }
971 schoenebeck 3293
972     void forkTo(VMExecContext* ectx) const OVERRIDE;
973 schoenebeck 3551
974     VMExpr* exitResult() OVERRIDE {
975     return exitRes.value;
976     }
977 schoenebeck 2581 };
978    
979     } // namespace LinuxSampler
980    
981     #endif // LS_INSTRPARSERTREE_H

  ViewVC Help
Powered by ViewVC