ast.h

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifndef LINGODEC_AST_H
#define LINGODEC_AST_H
 
#include "common/array.h"
#include "common/ptr.h"
#include "common/str.h"
#include "common/util.h"
#include "./enums.h"
 
namespace LingoDec {
 
struct CaseLabelNode;
struct Handler;
struct LoopNode;
struct Node;
struct RepeatWithInStmtNode;
 
/* Datum */
 
struct Datum {
    DatumType type;
    int i = -1;
    double f = 0.0f;
    Common::String s;
    Common::Array<Common::SharedPtr<Node>> l;
 
    Datum() {
        type = kDatumVoid;
    }
    Datum(int val) {
        type = kDatumInt;
        i = val;
    }
    Datum(double val) {
        type = kDatumFloat;
        f = val;
    }
    Datum(DatumType t, Common::String val) {
        type = t;
        s = val;
    }
    Datum(DatumType t, Common::Array<Common::SharedPtr<Node>> val) {
        type = t;
        l = val;
    }
 
    int toInt();
};
 
class NodeVisitor;
 
/* Node */
 
struct Node {
    NodeType type;
    bool isExpression;
    bool isStatement;
    bool isLabel;
    bool isLoop;
    Node *parent;
    uint32 _startOffset;
    uint32 _endOffset;
 
    Node(NodeType t, uint32 offset) : type(t), isExpression(false), isStatement(false), isLabel(false), isLoop(false), parent(nullptr), _startOffset(offset), _endOffset(offset) {}
    virtual ~Node() {}
    virtual void accept(NodeVisitor& visitor) const = 0;
    virtual Common::SharedPtr<Datum> getValue();
    Node *ancestorStatement();
    LoopNode *ancestorLoop();
    virtual bool hasSpaces(bool dot);
};
 
/* ExprNode */
 
struct ExprNode : Node {
    ExprNode(NodeType t, uint32 offset) : Node(t, offset) {
        isExpression = true;
    }
};
 
/* StmtNode */
 
struct StmtNode : Node {
    StmtNode(NodeType t, uint32 offset) : Node(t, offset) {
        isStatement = true;
    }
};
 
/* LabelNode */
 
struct LabelNode : Node {
    LabelNode(NodeType t, uint32 offset) : Node(t, offset) {
        isLabel = true;
    }
};
 
/* LoopNode */
 
struct LoopNode : StmtNode {
    uint32 startIndex;
 
    LoopNode(NodeType t, uint32 startIndex_, uint32 offset) : StmtNode(t, offset), startIndex(startIndex_) {
        isLoop = true;
    }
};
 
/* ErrorNode */
 
struct ErrorNode : ExprNode {
    explicit ErrorNode(uint32 offset) : ExprNode(kErrorNode, offset) {}
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* CommentNode */
 
struct CommentNode : Node {
    Common::String text;
 
    CommentNode(uint32 offset, Common::String t) : Node(kCommentNode, offset), text(t) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* LiteralNode */
 
struct LiteralNode : ExprNode {
    Common::SharedPtr<Datum> value;
 
    LiteralNode(uint32 offset, Common::SharedPtr<Datum> d) : ExprNode(kLiteralNode, offset) {
        value = Common::move(d);
    }
    Common::SharedPtr<Datum> getValue() override;
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* BlockNode */
 
struct BlockNode : Node {
    Common::Array<Common::SharedPtr<Node>> children;
 
    // for use during translation:
    uint32 endPos;
    CaseLabelNode *currentCaseLabel = nullptr;
 
    explicit BlockNode(uint32 offset) : Node(kBlockNode, offset), endPos(Common::String::npos) {}
    void addChild(Common::SharedPtr<Node> child);
    void accept(NodeVisitor &visitor) const override;
};
 
/* HandlerNode */
 
struct HandlerNode : Node {
    Handler *handler;
    Common::SharedPtr<BlockNode> block;
 
    HandlerNode(uint32 offset, Handler *h)
        : Node(kHandlerNode, offset), handler(h) {
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* ExitStmtNode */
 
struct ExitStmtNode : StmtNode {
    explicit ExitStmtNode(uint32 offset) : StmtNode(kExitStmtNode, offset) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* InverseOpNode */
 
struct InverseOpNode : ExprNode {
    Common::SharedPtr<Node> operand;
 
    InverseOpNode(uint32 offset, Common::SharedPtr<Node> o) : ExprNode(kInverseOpNode, offset) {
        operand = Common::move(o);
        operand->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* NotOpNode */
 
struct NotOpNode : ExprNode {
    Common::SharedPtr<Node> operand;
 
    NotOpNode(uint32 offset, Common::SharedPtr<Node> o) : ExprNode(kNotOpNode, offset) {
        operand = Common::move(o);
        operand->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* BinaryOpNode */
 
struct BinaryOpNode : ExprNode {
    OpCode opcode;
    Common::SharedPtr<Node> left;
    Common::SharedPtr<Node> right;
 
    BinaryOpNode(uint32 offset, OpCode op, Common::SharedPtr<Node> a, Common::SharedPtr<Node> b)
        : ExprNode(kBinaryOpNode, offset), opcode(op) {
        left = Common::move(a);
        left->parent = this;
        right = Common::move(b);
        right->parent = this;
    }
    virtual unsigned int getPrecedence() const;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ChunkExprNode */
 
struct ChunkExprNode : ExprNode {
    ChunkExprType type;
    Common::SharedPtr<Node> first;
    Common::SharedPtr<Node> last;
    Common::SharedPtr<Node> string;
 
    ChunkExprNode(uint32 offset, ChunkExprType t, Common::SharedPtr<Node> a, Common::SharedPtr<Node> b, Common::SharedPtr<Node> s)
        : ExprNode(kChunkExprNode, offset), type(t) {
        first = Common::move(a);
        first->parent = this;
        last = Common::move(b);
        last->parent = this;
        string = Common::move(s);
        string->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* ChunkHiliteStmtNode */
 
struct ChunkHiliteStmtNode : StmtNode {
    Common::SharedPtr<Node> chunk;
 
    ChunkHiliteStmtNode(uint32 offset, Common::SharedPtr<Node> c) : StmtNode(kChunkHiliteStmtNode, offset) {
        chunk = Common::move(c);
        chunk->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* ChunkDeleteStmtNode */
 
struct ChunkDeleteStmtNode : StmtNode {
    Common::SharedPtr<Node> chunk;
 
    ChunkDeleteStmtNode(uint32 offset, Common::SharedPtr<Node> c) : StmtNode(kChunkDeleteStmtNode, offset) {
        chunk = Common::move(c);
        chunk->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* SpriteIntersectsExprNode */
 
struct SpriteIntersectsExprNode : ExprNode {
    Common::SharedPtr<Node> firstSprite;
    Common::SharedPtr<Node> secondSprite;
 
    SpriteIntersectsExprNode(uint32 offset, Common::SharedPtr<Node> a, Common::SharedPtr<Node> b)
        : ExprNode(kSpriteIntersectsExprNode, offset) {
        firstSprite = Common::move(a);
        firstSprite->parent = this;
        secondSprite = Common::move(b);
        secondSprite->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* SpriteWithinExprNode */
 
struct SpriteWithinExprNode : ExprNode {
    Common::SharedPtr<Node> firstSprite;
    Common::SharedPtr<Node> secondSprite;
 
    SpriteWithinExprNode(uint32 offset, Common::SharedPtr<Node> a, Common::SharedPtr<Node> b)
        : ExprNode(kSpriteWithinExprNode, offset) {
        firstSprite = Common::move(a);
        firstSprite->parent = this;
        secondSprite = Common::move(b);
        secondSprite->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* MemberExprNode */
 
struct MemberExprNode : ExprNode {
    Common::String type;
    Common::SharedPtr<Node> memberID;
    Common::SharedPtr<Node> castID;
 
    MemberExprNode(uint32 offset, Common::String type_, Common::SharedPtr<Node> memberID_, Common::SharedPtr<Node> castID_)
        : ExprNode(kMemberExprNode, offset), type(type_) {
        this->memberID = Common::move(memberID_);
        this->memberID->parent = this;
        if (castID_) {
            this->castID = Common::move(castID_);
            this->castID->parent = this;
        }
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* VarNode */
 
struct VarNode : ExprNode {
    Common::String varName;
 
    VarNode(uint32 offset, Common::String v) : ExprNode(kVarNode, offset), varName(v) {}
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* AssignmentStmtNode */
 
struct AssignmentStmtNode : StmtNode {
    Common::SharedPtr<Node> variable;
    Common::SharedPtr<Node> value;
    bool forceVerbose;
 
    AssignmentStmtNode(uint32 offset, Common::SharedPtr<Node> var, Common::SharedPtr<Node> val, bool forceVerbose_ = false)
        : StmtNode(kAssignmentStmtNode, offset), forceVerbose(forceVerbose_) {
        variable = Common::move(var);
        variable->parent = this;
        value = Common::move(val);
        value->parent = this;
    }
 
    void accept(NodeVisitor &visitor) const override;
};
 
/* IfStmtNode */
 
struct IfStmtNode : StmtNode {
    bool hasElse;
    Common::SharedPtr<Node> condition;
    Common::SharedPtr<BlockNode> block1;
    Common::SharedPtr<BlockNode> block2;
 
    IfStmtNode(uint32 offset, Common::SharedPtr<Node> c) : StmtNode(kIfStmtNode, offset), hasElse(false) {
        condition = Common::move(c);
        condition->parent = this;
        block1 = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block1->parent = this;
        block2 = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block2->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* RepeatWhileStmtNode */
 
struct RepeatWhileStmtNode : LoopNode {
    Common::SharedPtr<Node> condition;
    Common::SharedPtr<BlockNode> block;
 
    RepeatWhileStmtNode(uint32 startIndex_, Common::SharedPtr<Node> c, uint32 offset)
        : LoopNode(kRepeatWhileStmtNode, startIndex_, offset) {
        condition = Common::move(c);
        condition->parent = this;
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* RepeatWithInStmtNode */
 
struct RepeatWithInStmtNode : LoopNode {
    Common::String varName;
    Common::SharedPtr<Node> list;
    Common::SharedPtr<BlockNode> block;
 
    RepeatWithInStmtNode(uint32 startIndex_, Common::String v, Common::SharedPtr<Node> l, uint32 offset)
        : LoopNode(kRepeatWithInStmtNode, startIndex_, offset) {
        varName = v;
        list = Common::move(l);
        list->parent = this;
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* RepeatWithToStmtNode */
 
struct RepeatWithToStmtNode : LoopNode {
    Common::String varName;
    Common::SharedPtr<Node> start;
    bool up;
    Common::SharedPtr<Node> end;
    Common::SharedPtr<BlockNode> block;
 
    RepeatWithToStmtNode(uint32 startIndex_, Common::String v, Common::SharedPtr<Node> s, bool _up, Common::SharedPtr<Node> e, uint32 offset)
        : LoopNode(kRepeatWithToStmtNode, startIndex_, offset), up(_up) {
        varName = v;
        start = Common::move(s);
        start->parent = this;
        end = Common::move(e);
        end->parent = this;
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* CaseLabelNode */
 
struct CaseLabelNode : LabelNode {
    Common::SharedPtr<Node> value;
    CaseExpect expect;
 
    Common::SharedPtr<CaseLabelNode> nextOr;
 
    Common::SharedPtr<CaseLabelNode> nextLabel;
    Common::SharedPtr<BlockNode> block;
 
    CaseLabelNode(uint32 offset, Common::SharedPtr<Node> v, CaseExpect e) : LabelNode(kCaseLabelNode, offset), expect(e) {
        value = Common::move(v);
        value->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* OtherwiseNode */
 
struct OtherwiseNode : LabelNode {
    Common::SharedPtr<BlockNode> block;
 
    explicit OtherwiseNode(uint32 offset) : LabelNode(kOtherwiseNode, offset) {
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* EndCaseNode */
 
struct EndCaseNode : LabelNode {
    explicit EndCaseNode(uint32 offset) : LabelNode(kEndCaseNode, offset) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* CaseStmtNode */
 
struct CaseStmtNode : StmtNode {
    Common::SharedPtr<Node> value;
    Common::SharedPtr<CaseLabelNode> firstLabel;
    Common::SharedPtr<OtherwiseNode> otherwise;
 
    // for use during translation:
    int32 endPos = -1;
    int32 potentialOtherwisePos = -1;
 
    CaseStmtNode(uint32 offset, Common::SharedPtr<Node> v) : StmtNode(kCaseStmtNode, offset) {
        value = Common::move(v);
        value->parent = this;
    }
    void addOtherwise(uint32 offset);
    void accept(NodeVisitor &visitor) const override;
};
 
/* TellStmtNode */
 
struct TellStmtNode : StmtNode {
    Common::SharedPtr<Node> window;
    Common::SharedPtr<BlockNode> block;
 
    TellStmtNode(uint32 offset, Common::SharedPtr<Node> w) : StmtNode(kTellStmtNode, offset) {
        window = Common::move(w);
        window->parent = this;
        block = Common::SharedPtr<BlockNode>(new BlockNode(offset));
        block->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* SoundCmdStmtNode */
 
struct SoundCmdStmtNode : StmtNode {
    Common::String cmd;
    Common::SharedPtr<Node> argList;
 
    SoundCmdStmtNode(uint32 offset, Common::String c, Common::SharedPtr<Node> a) : StmtNode(kSoundCmdStmtNode, offset) {
        cmd = c;
        argList = Common::move(a);
        argList->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* PlayCmdStmtNode */
 
struct PlayCmdStmtNode : StmtNode {
    Common::SharedPtr<Node> argList;
 
    PlayCmdStmtNode(uint32 offset, Common::SharedPtr<Node> a) : StmtNode(kPlayCmdStmtNode, offset) {
        argList = Common::move(a);
        argList->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* CallNode */
 
struct CallNode : Node {
    Common::String name;
    Common::SharedPtr<Node> argList;
 
    CallNode(uint32 offset, Common::String n, Common::SharedPtr<Node> a) : Node(kCallNode, offset) {
        name = n;
        argList = Common::move(a);
        argList->parent = this;
        if (argList->getValue()->type == kDatumArgListNoRet)
            isStatement = true;
        else
            isExpression = true;
    }
    bool noParens() const;
    bool isMemberExpr() const;
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ObjCallNode */
 
struct ObjCallNode : Node {
    Common::String name;
    Common::SharedPtr<Node> argList;
 
    ObjCallNode(uint32 offset, Common::String n, Common::SharedPtr<Node> a) : Node(kObjCallNode, offset) {
        name = n;
        argList = Common::move(a);
        argList->parent = this;
        if (argList->getValue()->type == kDatumArgListNoRet)
            isStatement = true;
        else
            isExpression = true;
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ObjCallV4Node */
 
struct ObjCallV4Node : Node {
    Common::SharedPtr<Node> obj;
    Common::SharedPtr<Node> argList;
 
    ObjCallV4Node(uint32 offset, Common::SharedPtr<Node> o, Common::SharedPtr<Node> a) : Node(kObjCallV4Node, offset) {
        obj = o;
        argList = Common::move(a);
        argList->parent = this;
        if (argList->getValue()->type == kDatumArgListNoRet)
            isStatement = true;
        else
            isExpression = true;
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* TheExprNode */
 
struct TheExprNode : ExprNode {
    Common::String prop;
 
    TheExprNode(uint32 offset, Common::String p) : ExprNode(kTheExprNode, offset), prop(p) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* LastStringChunkExprNode */
 
struct LastStringChunkExprNode : ExprNode {
    ChunkExprType type;
    Common::SharedPtr<Node> obj;
 
    LastStringChunkExprNode(uint32 offset, ChunkExprType t, Common::SharedPtr<Node> o)
        : ExprNode(kLastStringChunkExprNode, offset), type(t) {
        obj = Common::move(o);
        obj->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* StringChunkCountExprNode */
 
struct StringChunkCountExprNode : ExprNode {
    ChunkExprType type;
    Common::SharedPtr<Node> obj;
 
    StringChunkCountExprNode(uint32 offset, ChunkExprType t, Common::SharedPtr<Node> o)
        : ExprNode(kStringChunkCountExprNode, offset), type(t) {
        obj = Common::move(o);
        obj->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* MenuPropExprNode */
 
struct MenuPropExprNode : ExprNode {
    Common::SharedPtr<Node> menuID;
    unsigned int prop;
 
    MenuPropExprNode(uint32 offset, Common::SharedPtr<Node> m, unsigned int p)
        : ExprNode(kMenuPropExprNode, offset), prop(p) {
        menuID = Common::move(m);
        menuID->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* MenuItemPropExprNode */
 
struct MenuItemPropExprNode : ExprNode {
    Common::SharedPtr<Node> menuID;
    Common::SharedPtr<Node> itemID;
    unsigned int prop;
 
    MenuItemPropExprNode(uint32 offset, Common::SharedPtr<Node> m, Common::SharedPtr<Node> i, unsigned int p)
        : ExprNode(kMenuItemPropExprNode, offset), prop(p) {
        menuID = Common::move(m);
        menuID->parent = this;
        itemID = Common::move(i);
        itemID->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* SoundPropExprNode */
 
struct SoundPropExprNode : ExprNode {
    Common::SharedPtr<Node> soundID;
    unsigned int prop;
 
    SoundPropExprNode(uint32 offset, Common::SharedPtr<Node> s, unsigned int p)
        : ExprNode(kSoundPropExprNode, offset), prop(p) {
        soundID = Common::move(s);
        soundID->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* SpritePropExprNode */
 
struct SpritePropExprNode : ExprNode {
    Common::SharedPtr<Node> spriteID;
    unsigned int prop;
 
    SpritePropExprNode(uint32 offset, Common::SharedPtr<Node> s, unsigned int p)
        : ExprNode(kSpritePropExprNode, offset), prop(p) {
        spriteID = Common::move(s);
        spriteID->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* ThePropExprNode */
 
struct ThePropExprNode : ExprNode {
    Common::SharedPtr<Node> obj;
    Common::String prop;
 
    ThePropExprNode(uint32 offset, Common::SharedPtr<Node> o, Common::String p)
        : ExprNode(kThePropExprNode, offset), prop(p) {
        obj = Common::move(o);
        obj->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* ObjPropExprNode */
 
struct ObjPropExprNode : ExprNode {
    Common::SharedPtr<Node> obj;
    Common::String prop;
 
    ObjPropExprNode(uint32 offset, Common::SharedPtr<Node> o, Common::String p)
        : ExprNode(kObjPropExprNode, offset), prop(p) {
        obj = Common::move(o);
        obj->parent = this;
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ObjBracketExprNode */
 
struct ObjBracketExprNode : ExprNode {
    Common::SharedPtr<Node> obj;
    Common::SharedPtr<Node> prop;
 
    ObjBracketExprNode(uint32 offset, Common::SharedPtr<Node> o, Common::SharedPtr<Node> p)
        : ExprNode(kObjBracketExprNode, offset) {
        obj = Common::move(o);
        obj->parent = this;
        prop = Common::move(p);
        prop->parent = this;
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ObjPropIndexExprNode */
 
struct ObjPropIndexExprNode : ExprNode {
    Common::SharedPtr<Node> obj;
    Common::String prop;
    Common::SharedPtr<Node> index;
    Common::SharedPtr<Node> index2;
 
    ObjPropIndexExprNode(uint32 offset, Common::SharedPtr<Node> o, Common::String p, Common::SharedPtr<Node> i, Common::SharedPtr<Node> i2)
        : ExprNode(kObjPropIndexExprNode, offset), prop(p) {
        obj = Common::move(o);
        obj->parent = this;
        index = Common::move(i);
        index->parent = this;
        if (i2) {
            index2 = Common::move(i2);
            index2->parent = this;
        }
    }
    bool hasSpaces(bool dot) override;
    void accept(NodeVisitor &visitor) const override;
};
 
/* ExitRepeatStmtNode */
 
struct ExitRepeatStmtNode : StmtNode {
    explicit ExitRepeatStmtNode(uint32 offset) : StmtNode(kExitRepeatStmtNode, offset) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* NextRepeatStmtNode */
 
struct NextRepeatStmtNode : StmtNode {
    explicit NextRepeatStmtNode(uint32 offset) : StmtNode(kNextRepeatStmtNode, offset) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* PutStmtNode */
 
struct PutStmtNode : StmtNode {
    PutType type;
    Common::SharedPtr<Node> variable;
    Common::SharedPtr<Node> value;
 
    PutStmtNode(uint32 offset, PutType t, Common::SharedPtr<Node> var, Common::SharedPtr<Node> val)
        : StmtNode(kPutStmtNode, offset), type(t) {
        variable = Common::move(var);
        variable->parent = this;
        value = Common::move(val);
        value->parent = this;
    }
    void accept(NodeVisitor &visitor) const override;
};
 
/* WhenStmtNode */
 
struct WhenStmtNode : StmtNode {
    int event;
    Common::String script;
 
    WhenStmtNode(uint32 offset, int e, Common::String s)
        : StmtNode(kWhenStmtNode, offset), event(e), script(s) {}
    void accept(NodeVisitor &visitor) const override;
};
 
/* NewObjNode */
 
struct NewObjNode : ExprNode {
    Common::String objType;
    Common::SharedPtr<Node> objArgs;
 
    NewObjNode(uint32 offset, Common::String o, Common::SharedPtr<Node> args) : ExprNode(kNewObjNode, offset), objType(o), objArgs(args) {}
    void accept(NodeVisitor &visitor) const override;
};
 
class NodeVisitor {
public:
    virtual ~NodeVisitor() {}
    virtual void visit(const HandlerNode &node) { defaultVisit(node); }
    virtual void visit(const ErrorNode &node) { defaultVisit(node); }
    virtual void visit(const CommentNode &node) { defaultVisit(node); }
    virtual void visit(const NewObjNode &node) { defaultVisit(node); }
    virtual void visit(const LiteralNode &node) { defaultVisit(node); }
    virtual void visit(const IfStmtNode &node) { defaultVisit(node); }
    virtual void visit(const EndCaseNode &node) { defaultVisit(node); }
    virtual void visit(const ObjCallNode &node) { defaultVisit(node); }
    virtual void visit(const PutStmtNode &node) { defaultVisit(node); }
    virtual void visit(const TheExprNode &node) { defaultVisit(node); }
    virtual void visit(const BinaryOpNode &node) { defaultVisit(node); }
    virtual void visit(const CaseStmtNode &node) { defaultVisit(node); }
    virtual void visit(const ExitStmtNode &node) { defaultVisit(node); }
    virtual void visit(const TellStmtNode &node) { defaultVisit(node); }
    virtual void visit(const WhenStmtNode &node) { defaultVisit(node); }
    virtual void visit(const CaseLabelNode &node) { defaultVisit(node); }
    virtual void visit(const ChunkExprNode &node) { defaultVisit(node); }
    virtual void visit(const InverseOpNode &node) { defaultVisit(node); }
    virtual void visit(const ObjCallV4Node &node) { defaultVisit(node); }
    virtual void visit(const OtherwiseNode &node) { defaultVisit(node); }
    virtual void visit(const MemberExprNode &node) { defaultVisit(node); }
    virtual void visit(const ObjPropExprNode &node) { defaultVisit(node); }
    virtual void visit(const PlayCmdStmtNode &node) { defaultVisit(node); }
    virtual void visit(const ThePropExprNode &node) { defaultVisit(node); }
    virtual void visit(const MenuPropExprNode &node) { defaultVisit(node); }
    virtual void visit(const SoundCmdStmtNode &node) { defaultVisit(node); }
    virtual void visit(const SoundPropExprNode &node) { defaultVisit(node); }
    virtual void visit(const AssignmentStmtNode &node) { defaultVisit(node); }
    virtual void visit(const ExitRepeatStmtNode &node) { defaultVisit(node); }
    virtual void visit(const NextRepeatStmtNode &node) { defaultVisit(node); }
    virtual void visit(const ObjBracketExprNode &node) { defaultVisit(node); }
    virtual void visit(const SpritePropExprNode &node) { defaultVisit(node); }
    virtual void visit(const ChunkDeleteStmtNode &node) { defaultVisit(node); }
    virtual void visit(const ChunkHiliteStmtNode &node) { defaultVisit(node); }
    virtual void visit(const RepeatWhileStmtNode &node) { defaultVisit(node); }
    virtual void visit(const MenuItemPropExprNode &node) { defaultVisit(node); }
    virtual void visit(const ObjPropIndexExprNode &node) { defaultVisit(node); }
    virtual void visit(const RepeatWithInStmtNode &node) { defaultVisit(node); }
    virtual void visit(const RepeatWithToStmtNode &node) { defaultVisit(node); }
    virtual void visit(const SpriteWithinExprNode &node) { defaultVisit(node); }
    virtual void visit(const LastStringChunkExprNode &node) { defaultVisit(node); }
    virtual void visit(const SpriteIntersectsExprNode &node) { defaultVisit(node); }
    virtual void visit(const StringChunkCountExprNode &node) { defaultVisit(node); }
    virtual void visit(const VarNode &node) { defaultVisit(node); }
    virtual void visit(const CallNode &node) { defaultVisit(node); }
    virtual void visit(const BlockNode &node) { defaultVisit(node); }
    virtual void visit(const NotOpNode &node) { defaultVisit(node); }
 
    virtual void defaultVisit(const Node &) {}
};
 
/* AST */
 
struct AST {
    Common::SharedPtr<HandlerNode> root;
    BlockNode *currentBlock;
 
    AST(uint32 offset, Handler *handler){
        root = Common::SharedPtr<HandlerNode>(new HandlerNode(offset, handler));
        currentBlock = root->block.get();
    }
 
    void addStatement(Common::SharedPtr<Node> statement);
    void enterBlock(BlockNode *block);
    void exitBlock();
};
 
} // namespace LingoDec
 
#endif // LINGODEC_AST_H