/[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 3056 - (hide annotations) (download) (as text)
Fri Dec 16 12:57:59 2016 UTC (7 years, 3 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 22674 byte(s)
* RT Instrument Scripts: Fixed crash when using built-in script function
  "by_marks()".
* LSCP Server: Fixed client connection not being closed after network error.
* Fixed some more few compiler warnings.
* Bumped version (2.0.0.svn33).

1 schoenebeck 2581 /* -*- c++ -*-
2     *
3 schoenebeck 2871 * Copyright (c) 2014 - 2016 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     #include "../common/global.h"
24     #include "../common/Ref.h"
25     #include "../common/ArrayList.h"
26     #include "common.h"
27    
28     namespace LinuxSampler {
29    
30     class ParserContext;
31     class ExecContext;
32    
33     enum StmtType_t {
34     STMT_LEAF,
35     STMT_LIST,
36     STMT_BRANCH,
37     STMT_LOOP,
38     };
39    
40     class Node {
41     public:
42     Node();
43     virtual ~Node();
44     virtual void dump(int level = 0) = 0;
45 schoenebeck 2645 virtual bool isPolyphonic() const = 0;
46 schoenebeck 2581 void printIndents(int n);
47     };
48     typedef Ref<Node> NodeRef;
49    
50     class Expression : virtual public VMExpr, virtual public Node {
51     public:
52     virtual ExprType_t exprType() const = 0;
53     virtual bool isConstExpr() const = 0;
54     virtual String evalCastToStr() = 0;
55     };
56     typedef Ref<Expression,Node> ExpressionRef;
57    
58     class IntExpr : virtual public VMIntExpr, virtual public Expression {
59     public:
60     ExprType_t exprType() const { return INT_EXPR; }
61     virtual int evalInt() = 0;
62     String evalCastToStr();
63     };
64     typedef Ref<IntExpr,Node> IntExprRef;
65    
66 schoenebeck 3056 /*class IntArrayExpr : virtual public VMIntArrayExpr, virtual public Expression {
67     public:
68     ExprType_t exprType() const { return INT_ARR_EXPR; }
69     String evalCastToStr();
70     };
71     typedef Ref<IntArrayExpr,Node> IntArrayExprRef;*/
72    
73 schoenebeck 2581 class StringExpr : virtual public VMStringExpr, virtual public Expression {
74     public:
75     ExprType_t exprType() const { return STRING_EXPR; }
76     virtual String evalStr() = 0;
77     String evalCastToStr() { return evalStr(); }
78     };
79     typedef Ref<StringExpr,Node> StringExprRef;
80    
81     class IntLiteral : virtual public IntExpr {
82     int value;
83     public:
84     IntLiteral(int value) : value(value) { }
85     int evalInt();
86     void dump(int level = 0);
87     bool isConstExpr() const { return true; }
88 schoenebeck 2645 bool isPolyphonic() const { return false; }
89 schoenebeck 2581 };
90     typedef Ref<IntLiteral,Node> IntLiteralRef;
91    
92     class StringLiteral : virtual public StringExpr {
93     public:
94     String value;
95     StringLiteral(const String& value) : value(value) { }
96     bool isConstExpr() const { return true; }
97     void dump(int level = 0);
98     String evalStr() { return value; }
99 schoenebeck 2645 bool isPolyphonic() const { return false; }
100 schoenebeck 2581 };
101     typedef Ref<StringLiteral,Node> StringLiteralRef;
102    
103     class Args : virtual public VMFnArgs, virtual public Node {
104     public:
105     std::vector<ExpressionRef> args;
106     void add(ExpressionRef arg) { args.push_back(arg); }
107     void dump(int level = 0);
108 schoenebeck 3054 int argsCount() const { return (int) args.size(); }
109 schoenebeck 2581 VMExpr* arg(int i) { return (i >= 0 && i < argsCount()) ? &*args.at(i) : NULL; }
110 schoenebeck 2645 bool isPolyphonic() const;
111 schoenebeck 2581 };
112     typedef Ref<Args,Node> ArgsRef;
113    
114 schoenebeck 2945 class Variable : virtual public VMVariable, virtual public Expression {
115 schoenebeck 2581 public:
116 schoenebeck 2945 bool isConstExpr() const OVERRIDE { return bConst; }
117     bool isAssignable() const OVERRIDE { return !bConst; }
118 schoenebeck 2581 virtual void assign(Expression* expr) = 0;
119 schoenebeck 2945 void assignExpr(VMExpr* expr) OVERRIDE { Expression* e = dynamic_cast<Expression*>(expr); if (e) assign(e); }
120 schoenebeck 2581 protected:
121     Variable(ParserContext* ctx, int _memPos, bool _bConst)
122     : context(ctx), memPos(_memPos), bConst(_bConst) {}
123    
124     ParserContext* context;
125     int memPos;
126     bool bConst;
127     };
128     typedef Ref<Variable,Node> VariableRef;
129    
130     class IntVariable : public Variable, virtual public IntExpr {
131     bool polyphonic;
132     public:
133     IntVariable(ParserContext* ctx);
134     void assign(Expression* expr);
135     int evalInt();
136     void dump(int level = 0);
137     bool isPolyphonic() const { return polyphonic; }
138     protected:
139     IntVariable(ParserContext* ctx, bool polyphonic, bool bConst, int size = 1);
140     };
141     typedef Ref<IntVariable,Node> IntVariableRef;
142    
143     class ConstIntVariable : public IntVariable {
144     public:
145     int value;
146    
147     ConstIntVariable(int value);
148     //ConstIntVariable(ParserContext* ctx, int value = 0);
149     void assign(Expression* expr);
150     int evalInt();
151     void dump(int level = 0);
152     };
153     typedef Ref<ConstIntVariable,Node> ConstIntVariableRef;
154    
155 schoenebeck 2594 class BuiltInIntVariable : public IntVariable {
156     String name;
157     VMIntRelPtr* ptr;
158     public:
159     BuiltInIntVariable(const String& name, VMIntRelPtr* ptr);
160 schoenebeck 2948 bool isAssignable() const OVERRIDE { return !ptr->readonly; }
161 schoenebeck 3054 void assign(Expression* expr) OVERRIDE;
162     int evalInt() OVERRIDE;
163     void dump(int level = 0) OVERRIDE;
164 schoenebeck 2594 };
165     typedef Ref<BuiltInIntVariable,Node> BuiltInIntVariableRef;
166    
167 schoenebeck 2581 class PolyphonicIntVariable : public IntVariable {
168     public:
169     PolyphonicIntVariable(ParserContext* ctx);
170     void dump(int level = 0);
171     };
172     typedef Ref<PolyphonicIntVariable,Node> PolyphonicIntVariableRef;
173    
174 schoenebeck 2619 class IntArrayVariable : public Variable, virtual public VMIntArrayExpr {
175 schoenebeck 2581 ArrayList<int> values;
176     public:
177     IntArrayVariable(ParserContext* ctx, int size);
178     IntArrayVariable(ParserContext* ctx, int size, ArgsRef values);
179     void assign(Expression* expr) {} // ignore scalar assignment
180 schoenebeck 2594 String evalCastToStr() { return ""; } // ignore scalar cast to string
181 schoenebeck 2581 ExprType_t exprType() const { return INT_ARR_EXPR; }
182 schoenebeck 2594 virtual int arraySize() const { return values.size(); }
183     virtual int evalIntElement(uint i);
184     virtual void assignIntElement(uint i, int value);
185     void dump(int level = 0);
186 schoenebeck 2645 bool isPolyphonic() const { return false; }
187 schoenebeck 2594 protected:
188     IntArrayVariable(ParserContext* ctx, bool bConst);
189     };
190     typedef Ref<IntArrayVariable,Node> IntArrayVariableRef;
191    
192     class BuiltInIntArrayVariable : public IntArrayVariable {
193     String name;
194     VMInt8Array* array;
195     public:
196     BuiltInIntArrayVariable(const String& name, VMInt8Array* array);
197     int arraySize() const { return array->size; }
198 schoenebeck 2581 int evalIntElement(uint i);
199     void assignIntElement(uint i, int value);
200     void dump(int level = 0);
201     };
202 schoenebeck 2594 typedef Ref<BuiltInIntArrayVariable,Node> BuiltInIntArrayVariableRef;
203 schoenebeck 2581
204     class IntArrayElement : public IntVariable {
205     IntArrayVariableRef array;
206     IntExprRef index;
207     public:
208     IntArrayElement(IntArrayVariableRef array, IntExprRef arrayIndex);
209     void assign(Expression* expr);
210     int evalInt();
211     void dump(int level = 0);
212     };
213     typedef Ref<IntArrayElement,Node> IntArrayElementRef;
214    
215     class StringVariable : public Variable, virtual public StringExpr {
216     public:
217     StringVariable(ParserContext* ctx);
218     void assign(Expression* expr);
219     String evalStr();
220     void dump(int level = 0);
221 schoenebeck 2645 bool isPolyphonic() const { return false; }
222 schoenebeck 2581 protected:
223     StringVariable(ParserContext* ctx, bool bConst);
224     };
225     typedef Ref<StringVariable,Node> StringVariableRef;
226    
227     class ConstStringVariable : public StringVariable {
228     public:
229     String value;
230    
231     ConstStringVariable(ParserContext* ctx, String value = "");
232     void assign(Expression* expr);
233     String evalStr();
234     void dump(int level = 0);
235     };
236     typedef Ref<ConstStringVariable,Node> ConstStringVariableRef;
237    
238     class BinaryOp : virtual public Expression {
239     protected:
240     ExpressionRef lhs;
241     ExpressionRef rhs;
242     public:
243     BinaryOp(ExpressionRef lhs, ExpressionRef rhs) : lhs(lhs), rhs(rhs) { }
244     bool isConstExpr() const { return lhs->isConstExpr() && rhs->isConstExpr(); }
245 schoenebeck 2645 bool isPolyphonic() const { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
246 schoenebeck 2581 };
247     typedef Ref<BinaryOp,Node> BinaryOpRef;
248    
249     class Add : virtual public BinaryOp, virtual public IntExpr {
250     public:
251     Add(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs, rhs) { }
252     int evalInt();
253     void dump(int level = 0);
254     };
255     typedef Ref<Add,Node> AddRef;
256    
257     class Sub : virtual public BinaryOp, virtual public IntExpr {
258     public:
259     Sub(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs, rhs) { }
260     int evalInt();
261     void dump(int level = 0);
262     };
263     typedef Ref<Sub,Node> SubRef;
264    
265     class Mul : virtual public BinaryOp, virtual public IntExpr {
266     public:
267     Mul(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs, rhs) { }
268     int evalInt();
269     void dump(int level = 0);
270     };
271     typedef Ref<Mul,Node> MulRef;
272    
273     class Div : virtual public BinaryOp, virtual public IntExpr {
274     public:
275     Div(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs, rhs) { }
276     int evalInt();
277     void dump(int level = 0);
278     };
279     typedef Ref<Div,Node> DivRef;
280    
281     class Mod : virtual public BinaryOp, virtual public IntExpr {
282     public:
283     Mod(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs, rhs) { }
284     int evalInt();
285     void dump(int level = 0);
286     };
287     typedef Ref<Mod,Node> ModRef;
288    
289     class Statement : virtual public Node {
290     public:
291     virtual StmtType_t statementType() const = 0;
292     };
293     typedef Ref<Statement,Node> StatementRef;
294    
295     // Just used by parser to avoid "not a statement" parser warning, will be
296     // filtered out by parser. So it will not be part of the VM tree after parsing.
297     class NoOperation : public Statement {
298     public:
299     NoOperation() : Statement() {}
300     StmtType_t statementType() const { return STMT_LEAF; }
301     void dump(int level = 0) {}
302 schoenebeck 2645 bool isPolyphonic() const { return false; }
303 schoenebeck 2581 };
304     typedef Ref<NoOperation,Node> NoOperationRef;
305    
306     bool isNoOperation(StatementRef statement);
307    
308     class LeafStatement : public Statement {
309     public:
310     virtual StmtFlags_t exec() = 0;
311     virtual StmtType_t statementType() const { return STMT_LEAF; }
312     };
313     typedef Ref<LeafStatement,Node> LeafStatementRef;
314    
315     class Statements : public Statement {
316     std::vector<StatementRef> args;
317     public:
318     void add(StatementRef arg) { args.push_back(arg); }
319     void dump(int level = 0);
320     StmtType_t statementType() const { return STMT_LIST; }
321     virtual Statement* statement(uint i);
322 schoenebeck 2645 bool isPolyphonic() const;
323 schoenebeck 2581 };
324     typedef Ref<Statements,Node> StatementsRef;
325    
326     class BranchStatement : public Statement {
327     public:
328     StmtType_t statementType() const { return STMT_BRANCH; }
329     virtual int evalBranch() = 0;
330     virtual Statements* branch(uint i) const = 0;
331     };
332    
333 schoenebeck 2942 class DynamicVariableCall : public Variable, virtual public IntExpr, virtual public StringExpr {
334     VMDynVar* dynVar;
335     String varName;
336     public:
337     DynamicVariableCall(const String& name, ParserContext* ctx, VMDynVar* v);
338     ExprType_t exprType() const OVERRIDE { return dynVar->exprType(); }
339     bool isConstExpr() const OVERRIDE { return dynVar->isConstExpr(); }
340     bool isAssignable() const OVERRIDE { return dynVar->isAssignable(); }
341     bool isPolyphonic() const OVERRIDE { return false; }
342 schoenebeck 2945 void assign(Expression* expr) OVERRIDE { dynVar->assignExpr(expr); }
343 schoenebeck 2942 int evalInt() OVERRIDE;
344     String evalStr() OVERRIDE;
345     String evalCastToStr() OVERRIDE;
346     void dump(int level = 0) OVERRIDE;
347     };
348     typedef Ref<DynamicVariableCall,Node> DynamicVariableCallRef;
349    
350 schoenebeck 2581 class FunctionCall : virtual public LeafStatement, virtual public IntExpr, virtual public StringExpr {
351     String functionName;
352     ArgsRef args;
353     VMFunction* fn;
354     public:
355     FunctionCall(const char* function, ArgsRef args, VMFunction* fn) :
356     functionName(function), args(args), fn(fn) { }
357     void dump(int level = 0);
358     StmtFlags_t exec();
359     int evalInt();
360 schoenebeck 3056 VMIntArrayExpr* asIntArray() const OVERRIDE;
361 schoenebeck 2581 String evalStr();
362     bool isConstExpr() const { return false; }
363     ExprType_t exprType() const;
364     String evalCastToStr();
365 schoenebeck 2645 bool isPolyphonic() const { return args->isPolyphonic(); }
366 schoenebeck 2581 protected:
367     VMFnResult* execVMFn();
368     };
369     typedef Ref<FunctionCall,Node> FunctionCallRef;
370    
371     class EventHandler : virtual public Statements, virtual public VMEventHandler {
372     StatementsRef statements;
373 schoenebeck 2645 bool usingPolyphonics;
374 schoenebeck 2581 public:
375     void dump(int level = 0);
376     StmtFlags_t exec();
377 schoenebeck 2645 EventHandler(StatementsRef statements);
378 schoenebeck 2581 Statement* statement(uint i) { return statements->statement(i); }
379 schoenebeck 2645 bool isPolyphonic() const { return usingPolyphonics; }
380 schoenebeck 2581 };
381     typedef Ref<EventHandler,Node> EventHandlerRef;
382    
383     class OnNote : public EventHandler {
384     public:
385     OnNote(StatementsRef statements) : EventHandler(statements) {}
386 schoenebeck 2879 VMEventHandlerType_t eventHandlerType() const { return VM_EVENT_HANDLER_NOTE; }
387 schoenebeck 2581 String eventHandlerName() const { return "note"; }
388     };
389     typedef Ref<OnNote,Node> OnNoteRef;
390    
391     class OnInit : public EventHandler {
392     public:
393     OnInit(StatementsRef statements) : EventHandler(statements) {}
394 schoenebeck 2879 VMEventHandlerType_t eventHandlerType() const { return VM_EVENT_HANDLER_INIT; }
395 schoenebeck 2581 String eventHandlerName() const { return "init"; }
396     };
397     typedef Ref<OnInit,Node> OnInitRef;
398    
399     class OnRelease : public EventHandler {
400     public:
401     OnRelease(StatementsRef statements) : EventHandler(statements) {}
402 schoenebeck 2879 VMEventHandlerType_t eventHandlerType() const { return VM_EVENT_HANDLER_RELEASE; }
403 schoenebeck 2581 String eventHandlerName() const { return "release"; }
404     };
405     typedef Ref<OnRelease,Node> OnReleaseRef;
406    
407     class OnController : public EventHandler {
408     public:
409     OnController(StatementsRef statements) : EventHandler(statements) {}
410 schoenebeck 2879 VMEventHandlerType_t eventHandlerType() const { return VM_EVENT_HANDLER_CONTROLLER; }
411 schoenebeck 2581 String eventHandlerName() const { return "controller"; }
412     };
413     typedef Ref<OnController,Node> OnControllerRef;
414    
415     class EventHandlers : virtual public Node {
416     std::vector<EventHandlerRef> args;
417     public:
418     EventHandlers();
419     ~EventHandlers();
420     void add(EventHandlerRef arg);
421     void dump(int level = 0);
422     int evalInt() { return 0; }
423     EventHandler* eventHandlerByName(const String& name) const;
424     EventHandler* eventHandler(uint index) const;
425 schoenebeck 3054 inline uint size() const { return (int) args.size(); }
426 schoenebeck 2645 bool isPolyphonic() const;
427 schoenebeck 2581 };
428     typedef Ref<EventHandlers,Node> EventHandlersRef;
429    
430     class Assignment : public LeafStatement {
431     protected:
432     VariableRef variable;
433     ExpressionRef value;
434     public:
435     Assignment(VariableRef variable, ExpressionRef value);
436     void dump(int level = 0);
437     StmtFlags_t exec();
438 schoenebeck 2871 bool isPolyphonic() const { return (variable && variable->isPolyphonic()) || (value && value->isPolyphonic()); }
439 schoenebeck 2581 };
440     typedef Ref<Assignment,Node> AssignmentRef;
441    
442     class If : public BranchStatement {
443     IntExprRef condition;
444     StatementsRef ifStatements;
445     StatementsRef elseStatements;
446     public:
447     If(IntExprRef condition, StatementsRef ifStatements, StatementsRef elseStatements) :
448     condition(condition), ifStatements(ifStatements), elseStatements(elseStatements) { }
449     If(IntExprRef condition, StatementsRef statements) :
450     condition(condition), ifStatements(statements) { }
451     void dump(int level = 0);
452     int evalBranch();
453     Statements* branch(uint i) const;
454 schoenebeck 2645 bool isPolyphonic() const;
455 schoenebeck 2581 };
456     typedef Ref<If,Node> IfRef;
457    
458     struct CaseBranch {
459     IntExprRef from;
460     IntExprRef to;
461     StatementsRef statements;
462     };
463    
464     typedef std::vector<CaseBranch> CaseBranches;
465    
466     class SelectCase : public BranchStatement {
467     IntExprRef select;
468     CaseBranches branches;
469     public:
470     SelectCase(IntExprRef select, const CaseBranches& branches) : select(select), branches(branches) { }
471     void dump(int level = 0);
472     int evalBranch();
473     Statements* branch(uint i) const;
474     //void addBranch(IntExprRef condition, StatementsRef statements);
475     //void addBranch(IntExprRef from, IntExprRef to, StatementsRef statements);
476     //void addBranch(CaseBranchRef branch);
477     //void addBranches(CaseBranchesRef branches);
478 schoenebeck 2645 bool isPolyphonic() const;
479 schoenebeck 2581 };
480     typedef Ref<SelectCase,Node> SelectCaseRef;
481    
482     class While : public Statement {
483     IntExprRef m_condition;
484     StatementsRef m_statements;
485     public:
486     While(IntExprRef condition, StatementsRef statements) :
487     m_condition(condition), m_statements(statements) {}
488     StmtType_t statementType() const { return STMT_LOOP; }
489     void dump(int level = 0);
490     bool evalLoopStartCondition();
491     Statements* statements() const;
492 schoenebeck 2645 bool isPolyphonic() const { return m_condition->isPolyphonic() || m_statements->isPolyphonic(); }
493 schoenebeck 2581 };
494    
495     class Neg : public IntExpr {
496     IntExprRef expr;
497     public:
498     Neg(IntExprRef expr) : expr(expr) { }
499     int evalInt() { return (expr) ? -expr->evalInt() : 0; }
500     void dump(int level = 0);
501     bool isConstExpr() const { return expr->isConstExpr(); }
502 schoenebeck 2645 bool isPolyphonic() const { return expr->isPolyphonic(); }
503 schoenebeck 2581 };
504     typedef Ref<Neg,Node> NegRef;
505    
506     class ConcatString : public StringExpr {
507     ExpressionRef lhs;
508     ExpressionRef rhs;
509     public:
510     ConcatString(ExpressionRef lhs, ExpressionRef rhs) : lhs(lhs), rhs(rhs) {}
511     String evalStr();
512     void dump(int level = 0);
513     bool isConstExpr() const;
514 schoenebeck 2645 bool isPolyphonic() const { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
515 schoenebeck 2581 };
516     typedef Ref<ConcatString,Node> ConcatStringRef;
517    
518     class Relation : public IntExpr {
519     public:
520     enum Type {
521     LESS_THAN,
522     GREATER_THAN,
523     LESS_OR_EQUAL,
524     GREATER_OR_EQUAL,
525     EQUAL,
526     NOT_EQUAL
527     };
528     Relation(IntExprRef lhs, Type type, IntExprRef rhs) :
529     lhs(lhs), rhs(rhs), type(type) {}
530     int evalInt();
531     void dump(int level = 0);
532     bool isConstExpr() const;
533 schoenebeck 2645 bool isPolyphonic() const { return lhs->isPolyphonic() || rhs->isPolyphonic(); }
534 schoenebeck 2581 private:
535     IntExprRef lhs;
536     IntExprRef rhs;
537     Type type;
538     };
539     typedef Ref<Relation,Node> RelationRef;
540    
541     class Or : virtual public BinaryOp, virtual public IntExpr {
542     public:
543     Or(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs,rhs) {}
544     int evalInt();
545     void dump(int level = 0);
546     };
547     typedef Ref<Or,Node> OrRef;
548    
549 schoenebeck 2935 class BitwiseOr : virtual public BinaryOp, virtual public IntExpr {
550     public:
551     BitwiseOr(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs,rhs) {}
552     int evalInt();
553     void dump(int level = 0);
554     };
555     typedef Ref<BitwiseOr,Node> BitwiseOrRef;
556    
557 schoenebeck 2581 class And : virtual public BinaryOp, virtual public IntExpr {
558     public:
559     And(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs,rhs) {}
560     int evalInt();
561     void dump(int level = 0);
562     };
563     typedef Ref<And,Node> AndRef;
564    
565 schoenebeck 2935 class BitwiseAnd : virtual public BinaryOp, virtual public IntExpr {
566     public:
567     BitwiseAnd(IntExprRef lhs, IntExprRef rhs) : BinaryOp(lhs,rhs) {}
568     int evalInt();
569     void dump(int level = 0);
570     };
571     typedef Ref<BitwiseAnd,Node> BitwiseAndRef;
572    
573 schoenebeck 2581 class Not : virtual public IntExpr {
574     IntExprRef expr;
575     public:
576     Not(IntExprRef expr) : expr(expr) {}
577     int evalInt() { return !expr->evalInt(); }
578     void dump(int level = 0);
579     bool isConstExpr() const { return expr->isConstExpr(); }
580 schoenebeck 2645 bool isPolyphonic() const { return expr->isPolyphonic(); }
581 schoenebeck 2581 };
582     typedef Ref<Not,Node> NotRef;
583    
584 schoenebeck 2935 class BitwiseNot : virtual public IntExpr {
585     IntExprRef expr;
586     public:
587     BitwiseNot(IntExprRef expr) : expr(expr) {}
588     int evalInt() { return ~expr->evalInt(); }
589     void dump(int level = 0);
590     bool isConstExpr() const { return expr->isConstExpr(); }
591     bool isPolyphonic() const { return expr->isPolyphonic(); }
592     };
593     typedef Ref<BitwiseNot,Node> BitwiseNotRef;
594    
595 schoenebeck 2581 class ParserContext : public VMParserContext {
596     public:
597     struct Error {
598     String txt;
599     int line;
600     };
601     typedef Error Warning;
602    
603     void* scanner;
604     std::istream* is;
605 schoenebeck 2588 std::vector<ParserIssue> vErrors;
606     std::vector<ParserIssue> vWarnings;
607     std::vector<ParserIssue> vIssues;
608 schoenebeck 2581
609     std::set<String> builtinPreprocessorConditions;
610     std::set<String> userPreprocessorConditions;
611    
612     std::map<String,VariableRef> vartable;
613 schoenebeck 2951 std::map<String,StatementsRef> userFnTable;
614 schoenebeck 2581 int globalIntVarCount;
615     int globalStrVarCount;
616     int polyphonicIntVarCount;
617    
618     EventHandlersRef handlers;
619    
620     OnInitRef onInit;
621     OnNoteRef onNote;
622     OnReleaseRef onRelease;
623     OnControllerRef onController;
624    
625     ArrayList<int>* globalIntMemory;
626     ArrayList<String>* globalStrMemory;
627 schoenebeck 2588 int requiredMaxStackSize;
628 schoenebeck 2581
629     VMFunctionProvider* functionProvider;
630    
631     ExecContext* execContext;
632    
633     ParserContext(VMFunctionProvider* parent) :
634     scanner(NULL), is(NULL),
635     globalIntVarCount(0), globalStrVarCount(0), polyphonicIntVarCount(0),
636 schoenebeck 2588 globalIntMemory(NULL), globalStrMemory(NULL), requiredMaxStackSize(-1),
637     functionProvider(parent), execContext(NULL)
638 schoenebeck 2581 {
639     }
640 schoenebeck 2588 virtual ~ParserContext();
641 schoenebeck 2581 VariableRef globalVar(const String& name);
642     IntVariableRef globalIntVar(const String& name);
643     StringVariableRef globalStrVar(const String& name);
644     VariableRef variableByName(const String& name);
645 schoenebeck 2951 StatementsRef userFunctionByName(const String& name);
646 schoenebeck 2889 void addErr(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt);
647     void addWrn(int firstLine, int lastLine, int firstColumn, int lastColumn, const char* txt);
648 schoenebeck 2581 void createScanner(std::istream* is);
649     void destroyScanner();
650     bool setPreprocessorCondition(const char* name);
651     bool resetPreprocessorCondition(const char* name);
652     bool isPreprocessorConditionSet(const char* name);
653 schoenebeck 2588 std::vector<ParserIssue> issues() const OVERRIDE;
654     std::vector<ParserIssue> errors() const OVERRIDE;
655     std::vector<ParserIssue> warnings() const OVERRIDE;
656     VMEventHandler* eventHandler(uint index) OVERRIDE;
657     VMEventHandler* eventHandlerByName(const String& name) OVERRIDE;
658 schoenebeck 2594 void registerBuiltInConstIntVariables(const std::map<String,int>& vars);
659     void registerBuiltInIntVariables(const std::map<String,VMIntRelPtr*>& vars);
660     void registerBuiltInIntArrayVariables(const std::map<String,VMInt8Array*>& vars);
661 schoenebeck 2942 void registerBuiltInDynVariables(const std::map<String,VMDynVar*>& vars);
662 schoenebeck 2581 };
663    
664     class ExecContext : public VMExecContext {
665     public:
666     struct StackFrame {
667     Statement* statement;
668     int subindex;
669    
670     StackFrame() {
671     statement = NULL;
672     subindex = -1;
673     }
674     };
675    
676     ArrayList<int> polyphonicIntMemory;
677     VMExecStatus_t status;
678     ArrayList<StackFrame> stack;
679     int stackFrame;
680     int suspendMicroseconds;
681    
682     ExecContext() :
683     status(VM_EXEC_NOT_RUNNING), stackFrame(-1), suspendMicroseconds(0) {}
684    
685     virtual ~ExecContext() {}
686    
687     inline void pushStack(Statement* stmt) {
688     stackFrame++;
689     //printf("pushStack() -> %d\n", stackFrame);
690     if (stackFrame >= stack.size()) return;
691     stack[stackFrame].statement = stmt;
692     stack[stackFrame].subindex = 0;
693     }
694    
695     inline void popStack() {
696     stack[stackFrame].statement = NULL;
697     stack[stackFrame].subindex = -1;
698     stackFrame--;
699     //printf("popStack() -> %d\n", stackFrame);
700     }
701    
702     inline void reset() {
703     stack[0].statement = NULL;
704     stack[0].subindex = -1;
705     stackFrame = -1;
706     }
707    
708 schoenebeck 2588 int suspensionTimeMicroseconds() const OVERRIDE {
709 schoenebeck 2581 return suspendMicroseconds;
710     }
711     };
712    
713     } // namespace LinuxSampler
714    
715     #endif // LS_INSTRPARSERTREE_H

  ViewVC Help
Powered by ViewVC