FieldCodeGenerator.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears 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.
 */
 
#pragma once
 
#include <deque>
#include <unordered_map>
#include <boost/algorithm/string.hpp>
#include "FieldScriptFormatter.h"
#include "installer/decompiler/CodeGenerator.h"
 
class FunctionMetaData{
 
    public:
 
        FunctionMetaData(std::string meta_data);
 
        bool IsStart() const;
 
        bool IsEnd() const;
 
        std::string GetEntityName();
 
        int GetCharacterId();
 
    private:
 
        static const std::string DELIMITER;
 
        static const std::string START;
 
        static const std::string END;
 
        void Parse(std::string meta_data);
 
        void ParseStart(const std::string& item, std::deque<std::string>& strs);
 
        void ParseEnd(const std::string& item, std::deque<std::string>& strs);
 
        void ParseCharId(const std::string& item, std::deque<std::string>& strs);
 
        void ParseEntity(const std::string& item, std::deque<std::string>& strs);
 
        bool end_ = false;
 
        bool start_ = false;
 
        std::string entity_name_;
 
        int character_id_ = -1;
 
};
 
class FieldCodeGenerator : public CodeGenerator{
 
    public:
 
        enum struct ValueType : int{
 
            Integer = 0,
 
            Float = 1
        };
 
        static const std::string FormatInstructionNotImplemented(
          const std::string& entity, uint32 address, uint32 opcode
        );
 
        static const std::string FormatInstructionNotImplemented(
          const std::string& entity, uint32 address, const Instruction& instruction
        );
 
        static const std::string FormatBool(uint32 value);
 
        static const std::string FormatInvertedBool(uint32 value);
 
        template<typename TValue>static const std::string FormatValueOrVariable(
          FieldScriptFormatter& formatter, uint32 bank, TValue value_or_address,
          ValueType type = ValueType::Integer, float scale = 1.0f
        ){
            switch (bank){
                case 0:
                    switch (type){
                        // TODO: check for zero
                        case ValueType::Float: return std::to_string(value_or_address / scale);
                        case ValueType::Integer: return std::to_string(value_or_address);
                        default: return std::to_string(value_or_address);
                    }
                case 1:
                case 2:
                case 3:
                case 13:
                case 15:
                    {
                        const auto address = static_cast<uint32>(value_or_address) & 0xFF;
                        const auto friendly_name = formatter.GetFriendlyVarName(
                          bank, value_or_address
                        );
                        if (friendly_name.empty())
                            return (boost::format("Banks[%1%][%2%]") % bank % address).str();
                        return (
                          boost::format("Banks[%1%][%2%]--[[%3%]]") % bank % address % friendly_name
                        ).str();
                    }
                case 5:
                case 6:
                    {
                        const auto address = static_cast<uint32>(value_or_address)& 0xFF;
                        const  auto friendly_name = formatter.GetFriendlyVarName(bank, address);
                        if (friendly_name.empty())
                            return (boost::format("Banks[%1%][%2%]") % bank % address).str();
                        return (
                          boost::format("Banks[%1%][%2%]--[[%3%]]") % bank % address % friendly_name
                        ).str();
                    }
                default:
                    return (
                      boost::format(
                        "Banks[%1%][%2%]"
                      ) % bank % (static_cast<uint32>(value_or_address) & 0xFF)
                    ).str();
            }
        }
 
        FieldCodeGenerator(
          Engine *engine, const InstVec& insts, std::ostream &output,
          FieldScriptFormatter& formatter
        ) :
          CodeGenerator(engine, output, FIFO_ARGUMENT_ORDER, LIFO_ARGUMENT_ORDER),
          insts_(insts), formatter_(formatter)
        {target_lang_ = std::make_unique<LuaLanguage>();}
 
        virtual void Generate(InstVec& insts, const Graph &graph) override;
 
        virtual void AddOutputLine(
          std::string line, bool unindent_before = false, bool indent_after = false
        ) override;
 
        float GetScaleFactor() const;
 
        FieldScriptFormatter& GetFormatter();
 
 
 
    protected:
 
        virtual std::string ConstructFuncSignature(const Function &function) override;
 
        virtual void OnEndFunction(const Function& function) override;
 
        virtual void OnBeforeStartFunction(const Function& function) override;
 
        virtual void OnStartFunction(const Function& function) override;
 
        virtual bool OutputOnlyRequiredLabels() const override;
 
    private:
 
        const InstVec& insts_;
 
        std::vector<CodeLine> lines_;
 
        FieldScriptFormatter& formatter_;
 
};