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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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