command.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef STARK_TOOLS_COMMAND_H
#define STARK_TOOLS_COMMAND_H

#include "common/array.h"
#include "common/hashmap.h"
#include "common/hash-ptr.h"

#include "engines/stark/resources/command.h"

namespace Stark {
namespace Tools {

class Block;
class DefinitionRegistry;

class Command {
public:
    enum ControlFlowType {
        kFlowNormal,
        kFlowBranch,
        kFlowEnd
    };
    typedef Common::Array<Resources::Command::Argument> ArgumentArray;

    Command(Command *command);
    Command(Resources::Command *resource);

    void printCall() const;

    uint16 getIndex() const;
    Resources::Command::SubType getSubType() const;
    bool hasSubtypeDescription() const;

    ArgumentArray getEffectiveArguments() const;

protected:
    struct SubTypeDesc {
        Resources::Command::SubType subType;
        const char *name;
        ControlFlowType controlFlowType;
    };

    static const SubTypeDesc *searchSubTypeDesc(Resources::Command::SubType subType);

    Common::String describeArguments(DefinitionRegistry *definitions) const;

    uint16 _index;
    Resources::Command::SubType _subType;
    const SubTypeDesc *_subTypeDesc;
    ArgumentArray _arguments;
};

class CFGCommand : public Command {
public:
    CFGCommand(Resources::Command *resource);

    bool isEntryPoint() const;

    bool isBranch() const;

    bool isBranchTarget() const;

    CFGCommand *getFollower() const;
    CFGCommand *getTrueBranch() const;
    CFGCommand *getFalseBranch() const;

    Block *getBlock() const;
    void setBlock(Block *block);

    void linkBranches(const Common::Array<CFGCommand *> &commands);

protected:
    void initBranches();

    static CFGCommand *findCommandWithIndex(const Common::Array<CFGCommand *> &commands, int32 index);

    int32 _followerIndex;
    int32 _trueBranchIndex;
    int32 _falseBranchIndex;

    CFGCommand *_follower;
    CFGCommand *_trueBranch;
    CFGCommand *_falseBranch;
    Common::Array<CFGCommand *> _predecessors;

    Block *_block;
};

class DefinitionRegistry {
public:
    void registerReference(const ResourceReference &reference);

    Common::String getFromReference(const ResourceReference &reference) const;

    void printAll() const;

private:
    typedef Common::HashMap<Resources::Object *, Common::String> DefinitionMap;

    Common::String stringToCamelCase(const Common::String &input);

    DefinitionMap _definitions;
};

} // End of namespace Tools
} // End of namespace Stark

#endif // STARK_TOOLS_COMMAND_H