CodeGenerator.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 <ostream>
#include <utility>
#include <memory>
#include <boost/intrusive_ptr.hpp>
 
#include "DecompilerException.h"
#include "Graph.h"
#include "LuaLanguage.h"
#include "Value.h"
 
 
class Engine;
 
class Function;
 
const int INDENT_SPACES = 4; 
 
enum ARGUMENT_ORDER{
 
    FIFO_ARGUMENT_ORDER,
 
    LIFO_ARGUMENT_ORDER
};
 
 
 
class CodeGenerator {
 
    public:
 
        CodeGenerator(
          Engine *engine, std::ostream &output, ARGUMENT_ORDER bin_order, ARGUMENT_ORDER call_order
        );
 
        virtual ~CodeGenerator();
 
        LuaLanguage& GetLanguage();
 
        void WriteFunctionCall(
          std::string function_name, std::string param_format, const std::vector<ValuePtr>& params
        );
 
        virtual void Generate(InstVec& insts, const Graph &graph);
 
        virtual void AddOutputLine(
          std::string line, bool unindent_before = false, bool indent_after = false
        );
 
        void WriteTodo(std::string class_name, std::string instruction);
 
        void WriteAssignment(ValuePtr dst, ValuePtr src);
 
        void AddArg(ValuePtr arg);
 
        virtual void ProcessSpecialMetadata(const InstPtr inst, char c, int pos);
 
        virtual ValueList GetArgList();
 
        virtual ARGUMENT_ORDER GetBinaryOrder();
 
    protected:
 
        void ProcessInst(Function& function, InstVec& insts, const InstPtr inst);
 
        void ProcessUncondJumpInst(Function& function, InstVec& insts, const InstPtr inst);
 
        void ProcessCondJumpInst(const InstPtr inst);
 
        std::string IndentString(std::string s);
 
        virtual std::string ConstructFuncSignature(const Function& function);
 
        virtual void OnBeforeStartFunction(const Function& function);
 
        virtual void OnEndFunction(const Function& function);
 
        virtual void OnStartFunction(const Function& function);
 
        virtual bool OutputOnlyRequiredLabels() const;
 
        void GeneratePass(InstVec& insts, const Graph& graph);
 
        bool is_label_pass_ = true;
 
        GroupPtr cur_group_;
 
        Engine *engine_;
 
        std::ostream &output_;
 
        ValueStack stack_;
 
        uint indent_level_;
 
        GraphVertex cur_vertex_;
 
        std::unique_ptr<LuaLanguage> target_lang_;
 
    private:
 
        void Process(Function& function, InstVec& insts, GraphVertex vertex);
 
        Graph graph_;
 
        const ARGUMENT_ORDER bin_order_;
 
        const ARGUMENT_ORDER call_order_;
 
        ValueList arg_list_;
 
};