Graph.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 <vector>
#include <boost/format.hpp>
#include <boost/version.hpp>
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning(disable:4512)
#pragma warning(disable:4100)
#endif
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphviz.hpp>
#ifdef _MSC_VER
#pragma warning (pop)
#endif
#include <boost/intrusive_ptr.hpp>
#include "instruction/Instruction.h"
#include "RefCounted.h"
 
enum GROUP_TYPE {
 
    GROUP_TYPE_NORMAL,
 
    GROUP_TYPE_WHILE,
 
    GROUP_TYPE_DO_WHILE,
 
    GROUP_TYPE_IF,
 
    GROUP_TYPE_BREAK,
 
    GROUP_TYPE_CONTINUE
};
 
struct Group;
 
typedef boost::intrusive_ptr<Group> GroupPtr;
 
typedef boost::property<boost::vertex_name_t, GroupPtr> GroupProperty;
 
typedef boost::property<boost::vertex_index_t, int, GroupProperty> GraphProperty;
 
struct IsJump {
 
    bool is_jump = false;
 
    IsJump();
 
    IsJump(bool jump);
 
    friend std::ostream &operator<<(std::ostream &output, IsJump is_jump){
        if (is_jump.is_jump) output << "empty";
        else output << "normal";
        return output;
    }
};
 
namespace boost {
 
    template <class Name> class ArrowheadWriter{
 
        public:
 
            explicit ArrowheadWriter(Name name): name(name){}
 
            template <class VertexOrEdge> void operator()(
              std::ostream& out, const VertexOrEdge& v
            ) const {
                out << "[arrowhead=\"" << get(name, v) << "\"]";
            }
 
        private:
 
            Name name;
    };
 
    template <class Name> inline ArrowheadWriter<Name> MakeArrowheadWriter(Name n) {
        return ArrowheadWriter<Name>(n);
    }
 
}
 
typedef boost::property<boost::edge_attribute_t, IsJump> EdgeProperty;
 
typedef boost::adjacency_list<boost::setS, boost::listS, boost::bidirectionalS, GraphProperty, EdgeProperty> Graph;
 
typedef Graph::vertex_descriptor GraphVertex;
 
typedef Graph::vertex_iterator VertexIterator;
 
typedef Graph::edge_descriptor GraphEdge;
 
typedef Graph::out_edge_iterator OutEdgeIterator;
 
typedef Graph::in_edge_iterator InEdgeIterator;
 
typedef std::pair<VertexIterator, VertexIterator> VertexRange;
 
typedef std::pair<OutEdgeIterator, OutEdgeIterator> OutEdgeRange;
 
typedef std::pair<InEdgeIterator, InEdgeIterator> InEdgeRange;
 
struct CodeLine {
 
    std::string line = "0";
 
    bool unindent_before = false;
 
    bool indent_after = false;
 
    CodeLine(const std::string& line, bool unindent_before, bool indent_after);
};
 
typedef std::vector<Group *> ElseEnds; // Weak references to groups ending else blocks.
 
typedef ElseEnds::iterator ElseEndIterator;
 
struct Group : public RefCounted {
 
        GraphVertex vertex;
 
        InstIterator start;
 
        InstIterator end;
 
        int stack_level;
 
        GROUP_TYPE type;
 
        bool start_else;
 
        ElseEnds end_else;
 
        Group *prev;
 
        Group *next;
 
        std::vector<CodeLine> code;
 
        bool coalesced_else;
 
        Group();
 
        Group(GraphVertex vertex, InstIterator start, InstIterator end, GroupPtr prev);
 
        friend std::ostream &operator<<(std::ostream &output, GroupPtr group){
            output << "{Block type: ";
            switch(group->type) {
                case GROUP_TYPE_NORMAL: output << "Normal"; break;
                case GROUP_TYPE_WHILE: output << "While condition"; break;
                case GROUP_TYPE_DO_WHILE: output << "Do-while condition"; break;
                case GROUP_TYPE_IF: output << "If condition"; break;
                case GROUP_TYPE_BREAK: output << "Break"; break;
                case GROUP_TYPE_CONTINUE: output << "Continue"; break;
            }
            output << "\\n";
            output << "Expected stack level: " << group->stack_level << "\\n";
            if (group->start_else) output << "Start of else\\n";
            for (ElseEndIterator it = group->end_else.begin(); it != group->end_else.end(); ++ it)
                output << boost::format("End of else at %08x\\n") % (*(*it)->start)->GetAddress();
            output << "|";
            ConstInstIterator inst = group->start;
            do {
                std::stringstream stream;
                stream << *inst;
#if (BOOST_VERSION >= 104500)
                output << stream.str();
#else
                std::string s = stream.str();
                for (std::string::iterator it = s.begin(); it != s.end(); ++it)
                    if (*it == '"') output << "\\\"";
                    else if (*it == '|') output << "\\|";
                    else if (*it == '{') output << "\\{";
                    else if (*it == '}') output << "\\}";
                    else output << *it;
#endif
                output << "\\n";
            } while (inst ++ != group->end);
            output << "}";
            return output;
        }
};
 
class Engine;
 
struct GraphProperties {
 
    public:
 
        GraphProperties(Engine *engine, const Graph &graph);
 
        GraphProperties(const GraphProperties& rhs);
 
        GraphProperties& operator = (const GraphProperties& rhs);
 
        void operator()(std::ostream& out) const;
 
    private:
 
        Engine *engine;
 
        const Graph* graph;
};