/[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 3573 by schoenebeck, Tue Aug 27 21:36:53 2019 UTC revision 3574 by schoenebeck, Wed Aug 28 08:26:54 2019 UTC
# Line 116  public: Line 116  public:
116  };  };
117  typedef Ref<StringExpr,Node> StringExprRef;  typedef Ref<StringExpr,Node> StringExprRef;
118    
119  class IntLiteral : public IntExpr {  class IntLiteral FINAL : public IntExpr {
120      bool finalVal;      bool finalVal;
121  public:  public:
122      vmint value;      vmint value;
# Line 131  public: Line 131  public:
131  };  };
132  typedef Ref<IntLiteral,Node> IntLiteralRef;  typedef Ref<IntLiteral,Node> IntLiteralRef;
133    
134  class RealLiteral : public RealExpr {  class RealLiteral FINAL : public RealExpr {
135      vmfloat value;      vmfloat value;
136      bool finalVal;      bool finalVal;
137  public:  public:
# Line 146  public: Line 146  public:
146  };  };
147  typedef Ref<RealLiteral,Node> RealLiteralRef;  typedef Ref<RealLiteral,Node> RealLiteralRef;
148    
149  class StringLiteral : virtual public StringExpr {  class StringLiteral FINAL : public StringExpr {
150  public:  public:
151      String value;      String value;
152      StringLiteral(const String& value) : value(value) { }      StringLiteral(const String& value) : value(value) { }
# Line 157  public: Line 157  public:
157  };  };
158  typedef Ref<StringLiteral,Node> StringLiteralRef;  typedef Ref<StringLiteral,Node> StringLiteralRef;
159    
160  class Args : virtual public VMFnArgs, virtual public Node {  class Args FINAL : virtual public VMFnArgs, virtual public Node {
161  public:  public:
162      std::vector<ExpressionRef> args;      std::vector<ExpressionRef> args;
163      void add(ExpressionRef arg) { args.push_back(arg); }      void add(ExpressionRef arg) { args.push_back(arg); }
# Line 220  protected: Line 220  protected:
220  };  };
221  typedef Ref<RealVariable,Node> RealVariableRef;  typedef Ref<RealVariable,Node> RealVariableRef;
222    
223  class ConstIntVariable : public IntVariable {  class ConstIntVariable FINAL : public IntVariable {
224  public:  public:
225      vmint value;      vmint value;
226    
# Line 231  public: Line 231  public:
231  };  };
232  typedef Ref<ConstIntVariable,Node> ConstIntVariableRef;  typedef Ref<ConstIntVariable,Node> ConstIntVariableRef;
233    
234  class ConstRealVariable : public RealVariable {  class ConstRealVariable FINAL : public RealVariable {
235  public:  public:
236      vmfloat value;      vmfloat value;
237    
# Line 242  public: Line 242  public:
242  };  };
243  typedef Ref<ConstRealVariable,Node> ConstRealVariableRef;  typedef Ref<ConstRealVariable,Node> ConstRealVariableRef;
244    
245  class BuiltInIntVariable : public IntVariable {  class BuiltInIntVariable FINAL : public IntVariable {
246      String name;      String name;
247      VMIntPtr* ptr;      VMIntPtr* ptr;
248  public:  public:
# Line 254  public: Line 254  public:
254  };  };
255  typedef Ref<BuiltInIntVariable,Node> BuiltInIntVariableRef;  typedef Ref<BuiltInIntVariable,Node> BuiltInIntVariableRef;
256    
257  class PolyphonicIntVariable : public IntVariable {  class PolyphonicIntVariable FINAL : public IntVariable {
258  public:  public:
259      PolyphonicIntVariable(ParserContext* ctx);      PolyphonicIntVariable(ParserContext* ctx);
260      void dump(int level = 0) OVERRIDE;      void dump(int level = 0) OVERRIDE;
261  };  };
262  typedef Ref<PolyphonicIntVariable,Node> PolyphonicIntVariableRef;  typedef Ref<PolyphonicIntVariable,Node> PolyphonicIntVariableRef;
263    
264  class PolyphonicRealVariable : public RealVariable {  class PolyphonicRealVariable FINAL : public RealVariable {
265  public:  public:
266      PolyphonicRealVariable(ParserContext* ctx);      PolyphonicRealVariable(ParserContext* ctx);
267      void dump(int level = 0) OVERRIDE;      void dump(int level = 0) OVERRIDE;
# Line 286  protected: Line 286  protected:
286  };  };
287  typedef Ref<IntArrayVariable,Node> IntArrayVariableRef;  typedef Ref<IntArrayVariable,Node> IntArrayVariableRef;
288    
289  class RealArrayVariable : public Variable, virtual public RealArrayExpr {  class RealArrayVariable FINAL : public Variable, virtual public RealArrayExpr {
290      ArrayList<vmfloat> values;      ArrayList<vmfloat> values;
291  public:  public:
292      RealArrayVariable(ParserContext* ctx, vmint size);      RealArrayVariable(ParserContext* ctx, vmint size);
# Line 304  protected: Line 304  protected:
304  };  };
305  typedef Ref<RealArrayVariable,Node> RealArrayVariableRef;  typedef Ref<RealArrayVariable,Node> RealArrayVariableRef;
306    
307  class BuiltInIntArrayVariable : public IntArrayVariable {  class BuiltInIntArrayVariable FINAL : public IntArrayVariable {
308      String name;      String name;
309      VMInt8Array* array;      VMInt8Array* array;
310  public:  public:
# Line 317  public: Line 317  public:
317  };  };
318  typedef Ref<BuiltInIntArrayVariable,Node> BuiltInIntArrayVariableRef;  typedef Ref<BuiltInIntArrayVariable,Node> BuiltInIntArrayVariableRef;
319    
320  class IntArrayElement : public IntVariable {  class IntArrayElement FINAL : public IntVariable {
321      IntArrayExprRef array;      IntArrayExprRef array;
322      IntExprRef index;      IntExprRef index;
323  public:  public:
# Line 328  public: Line 328  public:
328  };  };
329  typedef Ref<IntArrayElement,Node> IntArrayElementRef;  typedef Ref<IntArrayElement,Node> IntArrayElementRef;
330    
331  class RealArrayElement : public RealVariable {  class RealArrayElement FINAL : public RealVariable {
332      RealArrayExprRef array;      RealArrayExprRef array;
333      IntExprRef index;      IntExprRef index;
334  public:  public:
# Line 351  protected: Line 351  protected:
351  };  };
352  typedef Ref<StringVariable,Node> StringVariableRef;  typedef Ref<StringVariable,Node> StringVariableRef;
353    
354  class ConstStringVariable : public StringVariable {  class ConstStringVariable FINAL : public StringVariable {
355  public:  public:
356      String value;      String value;
357    
# Line 396  public: Line 396  public:
396  };  };
397  typedef Ref<VaritypeScalarBinaryOp,Node> VaritypeScalarBinaryOpRef;  typedef Ref<VaritypeScalarBinaryOp,Node> VaritypeScalarBinaryOpRef;
398    
399  class Add : public VaritypeScalarBinaryOp {  class Add FINAL : public VaritypeScalarBinaryOp {
400  public:  public:
401      Add(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }      Add(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
402      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 405  public: Line 405  public:
405  };  };
406  typedef Ref<Add,Node> AddRef;  typedef Ref<Add,Node> AddRef;
407    
408  class Sub : public VaritypeScalarBinaryOp {  class Sub FINAL : public VaritypeScalarBinaryOp {
409  public:  public:
410      Sub(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }      Sub(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
411      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 414  public: Line 414  public:
414  };  };
415  typedef Ref<Sub,Node> SubRef;  typedef Ref<Sub,Node> SubRef;
416    
417  class Mul : public VaritypeScalarBinaryOp {  class Mul FINAL : public VaritypeScalarBinaryOp {
418  public:  public:
419      Mul(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }      Mul(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
420      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 425  public: Line 425  public:
425  };  };
426  typedef Ref<Mul,Node> MulRef;  typedef Ref<Mul,Node> MulRef;
427    
428  class Div : public VaritypeScalarBinaryOp {  class Div FINAL : public VaritypeScalarBinaryOp {
429  public:  public:
430      Div(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }      Div(ScalarNumberExprRef lhs, ScalarNumberExprRef rhs) : VaritypeScalarBinaryOp(lhs, rhs) { }
431      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 436  public: Line 436  public:
436  };  };
437  typedef Ref<Div,Node> DivRef;  typedef Ref<Div,Node> DivRef;
438    
439  class Mod : public IntBinaryOp {  class Mod FINAL : public IntBinaryOp {
440  public:  public:
441      Mod(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs, rhs) { }      Mod(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs, rhs) { }
442      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 452  typedef Ref<Statement,Node> StatementRef Line 452  typedef Ref<Statement,Node> StatementRef
452    
453  // 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
454  // 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.
455  class NoOperation : public Statement {  class NoOperation FINAL : public Statement {
456  public:  public:
457      NoOperation() : Statement() {}      NoOperation() : Statement() {}
458      StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }      StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }
# Line 488  public: Line 488  public:
488      virtual Statements* branch(vmuint i) const = 0;      virtual Statements* branch(vmuint i) const = 0;
489  };  };
490    
491  class DynamicVariableCall : public Variable, virtual public IntExpr, virtual public StringExpr, virtual public IntArrayExpr {  class DynamicVariableCall FINAL : public Variable, virtual public IntExpr, virtual public StringExpr, virtual public IntArrayExpr {
492      VMDynVar* dynVar;      VMDynVar* dynVar;
493      String varName;      String varName;
494  public:  public:
# Line 538  protected: Line 538  protected:
538  };  };
539  typedef Ref<FunctionCall,Node> FunctionCallRef;  typedef Ref<FunctionCall,Node> FunctionCallRef;
540    
541  class NoFunctionCall : public FunctionCall {  class NoFunctionCall FINAL : public FunctionCall {
542  public:  public:
543      NoFunctionCall() : FunctionCall("nothing", new Args, NULL) {}      NoFunctionCall() : FunctionCall("nothing", new Args, NULL) {}
544      StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }      StmtType_t statementType() const OVERRIDE { return STMT_NOOP; }
# Line 557  public: Line 557  public:
557  };  };
558  typedef Ref<EventHandler,Node> EventHandlerRef;  typedef Ref<EventHandler,Node> EventHandlerRef;
559    
560  class OnNote : public EventHandler {  class OnNote FINAL : public EventHandler {
561  public:  public:
562      OnNote(StatementsRef statements) : EventHandler(statements) {}      OnNote(StatementsRef statements) : EventHandler(statements) {}
563      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_NOTE; }      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_NOTE; }
# Line 565  public: Line 565  public:
565  };  };
566  typedef Ref<OnNote,Node> OnNoteRef;  typedef Ref<OnNote,Node> OnNoteRef;
567    
568  class OnInit : public EventHandler {  class OnInit FINAL : public EventHandler {
569  public:  public:
570      OnInit(StatementsRef statements) : EventHandler(statements) {}      OnInit(StatementsRef statements) : EventHandler(statements) {}
571      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_INIT; }      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_INIT; }
# Line 573  public: Line 573  public:
573  };  };
574  typedef Ref<OnInit,Node> OnInitRef;  typedef Ref<OnInit,Node> OnInitRef;
575    
576  class OnRelease : public EventHandler {  class OnRelease FINAL : public EventHandler {
577  public:  public:
578      OnRelease(StatementsRef statements) : EventHandler(statements) {}      OnRelease(StatementsRef statements) : EventHandler(statements) {}
579      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_RELEASE; }      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_RELEASE; }
# Line 581  public: Line 581  public:
581  };  };
582  typedef Ref<OnRelease,Node> OnReleaseRef;  typedef Ref<OnRelease,Node> OnReleaseRef;
583    
584  class OnController : public EventHandler {  class OnController FINAL : public EventHandler {
585  public:  public:
586      OnController(StatementsRef statements) : EventHandler(statements) {}      OnController(StatementsRef statements) : EventHandler(statements) {}
587      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_CONTROLLER; }      VMEventHandlerType_t eventHandlerType() const OVERRIDE { return VM_EVENT_HANDLER_CONTROLLER; }
# Line 589  public: Line 589  public:
589  };  };
590  typedef Ref<OnController,Node> OnControllerRef;  typedef Ref<OnController,Node> OnControllerRef;
591    
592  class EventHandlers : virtual public Node {  class EventHandlers FINAL : virtual public Node {
593      std::vector<EventHandlerRef> args;      std::vector<EventHandlerRef> args;
594  public:  public:
595      EventHandlers();      EventHandlers();
# Line 603  public: Line 603  public:
603  };  };
604  typedef Ref<EventHandlers,Node> EventHandlersRef;  typedef Ref<EventHandlers,Node> EventHandlersRef;
605    
606  class Assignment : public LeafStatement {  class Assignment FINAL : public LeafStatement {
607  protected:  protected:
608      VariableRef variable;      VariableRef variable;
609      ExpressionRef value;      ExpressionRef value;
# Line 615  public: Line 615  public:
615  };  };
616  typedef Ref<Assignment,Node> AssignmentRef;  typedef Ref<Assignment,Node> AssignmentRef;
617    
618  class If : public BranchStatement {  class If FINAL : public BranchStatement {
619      IntExprRef condition;      IntExprRef condition;
620      StatementsRef ifStatements;      StatementsRef ifStatements;
621      StatementsRef elseStatements;      StatementsRef elseStatements;
# Line 631  public: Line 631  public:
631  };  };
632  typedef Ref<If,Node> IfRef;  typedef Ref<If,Node> IfRef;
633    
634  struct CaseBranch {  struct CaseBranch FINAL {
635      IntExprRef from;      IntExprRef from;
636      IntExprRef to;      IntExprRef to;
637      StatementsRef statements;      StatementsRef statements;
638  };  };
   
639  typedef std::vector<CaseBranch> CaseBranches;  typedef std::vector<CaseBranch> CaseBranches;
640    
641  class SelectCase : public BranchStatement {  class SelectCase FINAL : public BranchStatement {
642      IntExprRef select;      IntExprRef select;
643      CaseBranches branches;      CaseBranches branches;
644  public:  public:
# Line 655  public: Line 654  public:
654  };  };
655  typedef Ref<SelectCase,Node> SelectCaseRef;  typedef Ref<SelectCase,Node> SelectCaseRef;
656    
657  class While : public Statement {  class While FINAL : public Statement {
658      IntExprRef m_condition;      IntExprRef m_condition;
659      StatementsRef m_statements;      StatementsRef m_statements;
660  public:  public:
# Line 668  public: Line 667  public:
667      bool isPolyphonic() const OVERRIDE { return m_condition->isPolyphonic() || m_statements->isPolyphonic(); }      bool isPolyphonic() const OVERRIDE { return m_condition->isPolyphonic() || m_statements->isPolyphonic(); }
668  };  };
669    
670  class SyncBlock : public Statement {  class SyncBlock FINAL : public Statement {
671      StatementsRef m_statements;      StatementsRef m_statements;
672  public:  public:
673      SyncBlock(StatementsRef statements) : m_statements(statements) {}      SyncBlock(StatementsRef statements) : m_statements(statements) {}
# Line 679  public: Line 678  public:
678  };  };
679  typedef Ref<SyncBlock,Node> SyncBlockRef;  typedef Ref<SyncBlock,Node> SyncBlockRef;
680    
681  class Neg : public IntExpr {  class Neg FINAL : public IntExpr {
682      IntExprRef expr;      IntExprRef expr;
683  public:  public:
684      Neg(IntExprRef expr) : expr(expr) { }      Neg(IntExprRef expr) : expr(expr) { }
# Line 693  public: Line 692  public:
692  };  };
693  typedef Ref<Neg,Node> NegRef;  typedef Ref<Neg,Node> NegRef;
694    
695  class ConcatString : public StringExpr {  class ConcatString FINAL : public StringExpr {
696      ExpressionRef lhs;      ExpressionRef lhs;
697      ExpressionRef rhs;      ExpressionRef rhs;
698  public:  public:
# Line 705  public: Line 704  public:
704  };  };
705  typedef Ref<ConcatString,Node> ConcatStringRef;  typedef Ref<ConcatString,Node> ConcatStringRef;
706    
707  class Relation : public IntExpr {  class Relation FINAL : public IntExpr {
708  public:  public:
709      enum Type {      enum Type {
710          LESS_THAN,          LESS_THAN,
# Line 731  private: Line 730  private:
730  };  };
731  typedef Ref<Relation,Node> RelationRef;  typedef Ref<Relation,Node> RelationRef;
732    
733  class Or : public IntBinaryOp {  class Or FINAL : public IntBinaryOp {
734  public:  public:
735      Or(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}      Or(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
736      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 739  public: Line 738  public:
738  };  };
739  typedef Ref<Or,Node> OrRef;  typedef Ref<Or,Node> OrRef;
740    
741  class BitwiseOr : public IntBinaryOp {  class BitwiseOr FINAL : public IntBinaryOp {
742  public:  public:
743      BitwiseOr(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}      BitwiseOr(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
744      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 749  public: Line 748  public:
748  };  };
749  typedef Ref<BitwiseOr,Node> BitwiseOrRef;  typedef Ref<BitwiseOr,Node> BitwiseOrRef;
750    
751  class And : public IntBinaryOp {  class And FINAL : public IntBinaryOp {
752  public:  public:
753      And(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}      And(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
754      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 757  public: Line 756  public:
756  };  };
757  typedef Ref<And,Node> AndRef;  typedef Ref<And,Node> AndRef;
758    
759  class BitwiseAnd : public IntBinaryOp {  class BitwiseAnd FINAL : public IntBinaryOp {
760  public:  public:
761      BitwiseAnd(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}      BitwiseAnd(IntExprRef lhs, IntExprRef rhs) : IntBinaryOp(lhs,rhs) {}
762      vmint evalInt() OVERRIDE;      vmint evalInt() OVERRIDE;
# Line 767  public: Line 766  public:
766  };  };
767  typedef Ref<BitwiseAnd,Node> BitwiseAndRef;  typedef Ref<BitwiseAnd,Node> BitwiseAndRef;
768    
769  class Not : virtual public IntExpr {  class Not FINAL : virtual public IntExpr {
770      IntExprRef expr;      IntExprRef expr;
771  public:  public:
772      Not(IntExprRef expr) : expr(expr) {}      Not(IntExprRef expr) : expr(expr) {}
# Line 781  public: Line 780  public:
780  };  };
781  typedef Ref<Not,Node> NotRef;  typedef Ref<Not,Node> NotRef;
782    
783  class BitwiseNot : virtual public IntExpr {  class BitwiseNot FINAL : virtual public IntExpr {
784      IntExprRef expr;      IntExprRef expr;
785  public:  public:
786      BitwiseNot(IntExprRef expr) : expr(expr) {}      BitwiseNot(IntExprRef expr) : expr(expr) {}
# Line 795  public: Line 794  public:
794  };  };
795  typedef Ref<BitwiseNot,Node> BitwiseNotRef;  typedef Ref<BitwiseNot,Node> BitwiseNotRef;
796    
797  class Final : virtual public IntExpr, virtual public RealExpr {  class Final FINAL : virtual public IntExpr, virtual public RealExpr {
798      ScalarNumberExprRef expr;      ScalarNumberExprRef expr;
799  public:  public:
800      Final(ScalarNumberExprRef expr) : expr(expr) {}      Final(ScalarNumberExprRef expr) : expr(expr) {}
# Line 812  public: Line 811  public:
811  };  };
812  typedef Ref<Final,Node> FinalRef;  typedef Ref<Final,Node> FinalRef;
813    
814  class ParserContext : public VMParserContext {  class ParserContext FINAL : public VMParserContext {
815  public:  public:
816      struct Error {      struct Error {
817          String txt;          String txt;
# Line 890  public: Line 889  public:
889      void registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars);      void registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars);
890  };  };
891    
892  class ExecContext : public VMExecContext {  class ExecContext FINAL : public VMExecContext {
893  public:  public:
894      struct StackFrame {      struct StackFrame {
895          Statement* statement;          Statement* statement;
Legend:
Removed from v.3573  
changed lines
  Added in v.3574
  ViewVC Help
Powered by ViewVC