DefDataBase.h

Go to the documentation of this file.

 
#ifndef DEFPARSER_DATABASE_H
#define DEFPARSER_DATABASE_H
 
#include "limbo/thirdparty/lefdef/5.8/def/def/defiNet.hpp"
#include "limbo/thirdparty/lefdef/5.8/def/def/defiRowTrack.hpp"
#include "limbo/thirdparty/lefdef/5.8/def/def/defiVia.hpp"
#include <array>
#include <ostream>
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cassert>
#include <limbo/thirdparty/lefdef/5.8/def/def/defrReader.hpp>
#include <limbo/thirdparty/lefdef/5.8/def/def/defiAlias.hpp>

namespace DefParser {

using std::cout;
using std::endl;
using std::cerr;
using std::string; 
using std::vector;
using std::pair;
using std::make_pair;
using std::ostringstream;
typedef int int32_t;
typedef unsigned int uint32_t;
typedef long int64_t;

struct Item 
{
    virtual void print(ostringstream&) const {};
    friend std::ostream& operator<<(std::ostream& os, Item const& rhs)
    {
        std::ostringstream ss;
        rhs.print(ss);
        os << ss.str();
        return os;
    }

    friend ostringstream& operator<<(ostringstream& ss, Item const& rhs)
    {
        rhs.print(ss);
        return ss;
    }
};

struct Row : public Item
{
    string row_name; 
    string macro_name; 
    int32_t origin[2]; 
    string orient; 
    int32_t repeat[2]; 
    int32_t step[2]; 
    void reset()
    {
        row_name = macro_name = orient = "";
        origin[0] = origin[1]  = -1;
        repeat[0] = repeat[1] = -1;
        step[0] = step[1] = -1;
    }

    virtual void print(ostringstream& ss) const
    {
        ss << "//////// Row ////////" << endl
            << "row_name = " << row_name << endl 
            << "macro_name = " << macro_name << endl 
            << "origin = " << origin[0] << " " << origin[1] << endl 
            << "orient = " << orient << endl 
            << "repeat = " << repeat[0] << " " << repeat[1] << endl 
            << "step = " << step[0] << " " << step[1] << endl; 
    }
};

struct Component : public Item
{
    string comp_name; 
    string macro_name; 
    string status; 
    int32_t origin[2]; 
    string orient; 
    void reset()
    {
        comp_name = macro_name = status = orient = "";
        origin[0] = origin[1] = -1;
    }

    virtual void print(ostringstream& ss) const
    {
        ss << "//////// Component ////////" << endl
            << "comp_name = " << comp_name << endl 
            << "macro_name = " << macro_name << endl 
            << "status = " << status << endl 
            << "origin = " << origin[0] << " " << origin[1] << endl 
            << "orient = " << orient << endl; 
    }
};

struct PinPort : public Item
{
    string status; 
    int32_t origin[2]; 
    string orient; 
    vector<string> vLayer; 
    vector<vector<int32_t> > vBbox; 
    void reset()
    {
        status = orient = "";
        origin[0] = origin[1] = -1;
        vLayer.clear(); 
        vBbox.clear(); 
    }

    virtual void print(ostringstream& ss) const
    {
        ss << "//////// Port ////////" << endl
            << "status = " << status << endl 
            << "origin = " << origin[0] << " " << origin[1] << endl 
            << "orient = " << orient << endl; 
        for (uint32_t i = 0; i < vLayer.size(); ++i)
            ss << "layer " << vLayer[i] << " " << vBbox[i][0] << " " << vBbox[i][1] << " " << vBbox[i][2] << " " << vBbox[i][3] << endl;
    }
};

struct Pin : public Item
{
    string pin_name; 
    string net_name; 
    string direct; 
    string status; 
    int32_t origin[2]; 
    string orient; 
    vector<string> vLayer; 
    vector<vector<int32_t> > vBbox; 
    string use; 
  vector<PinPort> vPinPort; 
    void reset()
    {
        pin_name = net_name = direct = status = orient = "";
        origin[0] = origin[1] = -1;
        vLayer.clear(); 
        vBbox.clear(); 
        vPinPort.clear();
        use = "";
    }

    virtual void print(ostringstream& ss) const
    {
        ss << "//////// Pin ////////" << endl
            << "pin_name = " << pin_name << endl 
            << "net_name = " << net_name << endl 
            << "direct = " << direct << endl 
            << "status = " << status << endl 
            << "origin = " << origin[0] << " " << origin[1] << endl 
            << "orient = " << orient << endl; 
        for (uint32_t i = 0; i < vLayer.size(); ++i)
            ss << "layer " << vLayer[i] << " " << vBbox[i][0] << " " << vBbox[i][1] << " " << vBbox[i][2] << " " << vBbox[i][3] << endl;
        ss << "use = " << use << endl;
    for (uint32_t i = 0; i < vPinPort.size(); ++i)
      vPinPort[i].print(ss); 
    }
};

struct Net : public Item
{
    string net_name; 
    int32_t net_weight; 
    vector< std::pair<string, string> > vNetPin; 
    void reset()
    {
        net_name = "";
        net_weight = 1;
        vNetPin.clear();
    }

    virtual void print(ostringstream& ss) const
    {
        ss << "//////// Net ////////" << endl
            << "net_name = " << net_name << endl
            << "net_weight = " << net_weight << endl;
        for (uint32_t i = 0; i < vNetPin.size(); ++i)
            ss << "(" << vNetPin[i].first << ", " << vNetPin[i].second << ") ";
        ss << endl;
    }
};

struct Region : public Item
{
    string region_name; 
    string region_type; 
    std::vector<std::vector<int> > vRectangle; 
    std::vector<string> vPropertyName; 
    std::vector<string> vPropertyValue; 
    std::vector<char>  vPropertyType; 

    void reset()
    {
        region_name = "";
        region_type = "";
        vRectangle.clear();
        vPropertyName.clear();
        vPropertyValue.clear();
        vPropertyType.clear();
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Region ////////" << endl
            << "region_name = " << region_name << endl
            << "region_type = " << region_type << endl;
        for (uint32_t i = 0; i < vRectangle.size(); ++i)
            ss << "(" << vRectangle[i][0] << ", " << vRectangle[i][1] << ", " << vRectangle[i][2] << ", " << vRectangle[i][3] << ") "; 
        ss << endl; 
        for (uint32_t i = 0; i < vPropertyName.size(); ++i)
            ss << "Property " << vPropertyName[i] << " " << vPropertyType[i] << " " << vPropertyValue[i] << endl; 
    }
};

struct Group : public Item
{
    string group_name; 
    std::vector<string> vGroupMember; 
    string region_name; 
    int perim; 
    int maxx;
    int maxy; 
    std::vector<std::vector<int> > vRectangle; 
    std::vector<string> vPropertyName; 
    std::vector<string> vPropertyValue; 
    std::vector<char>  vPropertyType; 

    void reset()
    {
        group_name = "";
        vGroupMember.clear();
        region_name = "";
        perim = 0; 
        maxx = 0; 
        maxy = 0; 
        vRectangle.clear();
        vPropertyName.clear();
        vPropertyValue.clear();
        vPropertyType.clear();
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Group ////////" << endl
            << "group_name = " << group_name << endl
            << "region_name = " << region_name << endl
            << "perim = " << perim << endl 
            << "maxx = " << maxx << ", " << "maxy = " << maxy << endl; 
        ss << "vGroupMember[" << vGroupMember.size() << "] = ";
        for (uint32_t i = 0; i < vGroupMember.size(); ++i)
            ss << vGroupMember[i] << " ";
        ss << endl; 
        for (uint32_t i = 0; i < vRectangle.size(); ++i)
            ss << "(" << vRectangle[i][0] << ", " << vRectangle[i][1] << ", " << vRectangle[i][2] << ", " << vRectangle[i][3] << ") "; 
        ss << endl; 
        for (uint32_t i = 0; i < vPropertyName.size(); ++i)
            ss << "Property " << vPropertyName[i] << " " << vPropertyType[i] << " " << vPropertyValue[i] << endl; 
    }
};

struct Track : public Item
{
    string track_name; 
    std::vector<string> vLayerNames; 
    int start;
    int step;
    int num; 
    int firstTrackMask;
    int sameMask; 

    void reset()
    {
        track_name = "";
        vLayerNames.clear();
        start = 0;
        step = 0;
        num = 0;
        firstTrackMask = 0;
        sameMask = 0;
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Track ////////" << endl
            << "start = " << start << endl
            << "step  = " << step  << endl 
            << "num   = " << num   << endl
            << "Layer ";
        for (auto &layername: vLayerNames) {
            ss << layername << " ";
        }
        ss << endl;
    }
};

struct GCellGrid : public Item
{
    string gcellgrid_name; 
    int start;
    int step;
    int num; 

    void reset()
    {
        gcellgrid_name = "";
        start = 0;
        step = 0;
        num = 0;
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// GCellGrid ////////" << endl
            << "name  = " << gcellgrid_name << endl
            << "start = " << start << endl
            << "step  = " << step  << endl 
            << "num   = " << num   << endl;
    }
};
struct ViaType : public Item
{
    std::string viatype_name; 
    int x, y;

    void reset()
    {
        viatype_name = "";
        x = 0;
        y = 0;
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Via ////////" << endl
            << "type  = " << viatype_name << endl
            << "coord = ()" << x << ", " << y << ")" << endl;
    }
};
struct Via : public Item
{
    std::string viatype_name; 
    int x, y;

    void reset()
    {
        viatype_name = "";
        x = 0;
        y = 0;
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Via ////////" << endl
            << "type  = " << viatype_name << endl
            << "coord = ()" << x << ", " << y << ")" << endl;
    }
};

struct SNet : public Item
{
    std::string net_name; 
    std::string type;
    vector<vector<int>> shapes; 
    vector<Via> vias;
    

    void reset()
    {
        net_name = "";
        shapes.clear();
        vias.clear();
        type = "";
    }

    virtual void print(ostringstream& ss) const 
    {
        ss << "//////// Special Net ////////" << endl
            << "name  = " << net_name << endl
            << "type = " << type << endl
            << "vias = ";
        for (auto const& via: vias) {
            via.print(ss);
        }
        ss << endl << "shapes = ";
        for (auto const& rect: shapes) {
            ss << '(';
            for (int i = 0; i < rect.size(); ++i) {
                ss  << rect[i] << ", ";
            }
            ss << ") ";
        }
        ss << endl;
    }
};
// forward declaration
class DefDataBase
{
    public:
        virtual void set_def_dividerchar(string const&) = 0;
        virtual void set_def_busbitchars(string const&) = 0;
        virtual void set_def_version(string const&) = 0;
        virtual void set_def_design(string const&) = 0;
        virtual void set_def_unit(int) = 0;
        virtual void set_def_diearea(int, int, int, int) = 0;
        virtual void set_def_diearea(int, const int*, const int*);
        virtual void add_def_row(Row const&) = 0;
        virtual void add_def_component(Component const&) = 0;
        virtual void resize_def_component(int) = 0;
        virtual void add_def_pin(Pin const&) = 0;
        virtual void resize_def_pin(int)  = 0;
        virtual void add_def_net(Net const&) = 0;
        virtual void resize_def_net(int) = 0;
        virtual void add_def_track(defiTrack const&);
        virtual void add_def_gcellgrid(GCellGrid const&);
        virtual void add_def_snet(defiNet const&);
        virtual void add_def_via(defiVia const&);
        virtual void add_def_route_blockage(std::vector<std::vector<int> > const&, std::string const&);
        // check these callbacks at runtime 
        virtual void resize_def_blockage(int);
        virtual void add_def_placement_blockage(std::vector<std::vector<int> > const&);
        virtual void resize_def_region(int); 
        virtual void add_def_region(Region const&); 
        virtual void resize_def_group(int);
        virtual void add_def_group(Group const&); 
        virtual void end_def_design(); 
 
    protected:
        void def_user_cbk_reminder(const char* str) const;
};
 
} // namespace DefParser
 
#endif