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; |
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: |
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) { } |
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); } |
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 |
|
|
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 |
|
|
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: |
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; |
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); |
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: |
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: |
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: |
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 |
|
|
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; |
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; |
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; |
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; |
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; |
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; } |
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: |
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; } |
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; } |
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; } |
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; } |
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; } |
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(); |
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; |
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; |
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: |
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: |
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) {} |
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) { } |
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: |
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, |
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; |
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; |
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; |
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; |
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) {} |
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) {} |
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) {} |
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; |
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; |