GdsDriver.h

Go to the documentation of this file.

 
#ifndef _GDSPARSER_GDSDRIVER_H
#define _GDSPARSER_GDSDRIVER_H
 
#include <sstream>
#include <limbo/parsers/gdsii/stream/GdsReader.h>
#include <limbo/preprocessor/AssertMsg.h>
 
using std::ostringstream;

namespace GdsParser 
{

typedef int int32_t;
typedef unsigned int uint32_t;

struct GdsBoundary 
{
    int32_t layer; 
    int32_t datatype; 
    vector<vector<int32_t> > vPoint; 
    void reset()
    {
        layer = -1;
        datatype = -1;
        vPoint.clear();
    }
};

struct GdsText 
{
    int32_t layer; 
    int32_t texttype; 
    int32_t presentation; 
    int32_t strans; 
    double mag; 
    vector<int32_t> position; 
    string content; 
    GdsText() 
    {
        position.resize(2, 0);
    }

    void reset()
    {
        layer = texttype = presentation = strans = 0;
        mag = 0;
        position.resize(2, 0);
        content = "";
    }
};

struct GdsSref
{
    string sname; 
    vector<int32_t> position; 
    GdsSref() 
    {
        position.resize(2, 0);
    }

    void reset()
    {
        sname = "";
        position.resize(2, 0);
    }
};

struct GdsCell 
{
    string cell_name; 
    vector<GdsBoundary> vBoundary; 
    vector<GdsText> vText; 
    vector<GdsSref> vSref; 
    void reset()
    {
        cell_name = "";
        vBoundary.clear();
        vText.clear();
        vSref.clear();
    }
};

struct GdsLib 
{
    string lib_name; 
    vector<double> unit; 
    vector<GdsCell> vCell; 
    GdsLib()
    {
        unit.resize(2, 0);
    }

    void reset()
    {
        lib_name = "";
        unit.resize(2, 0);
        vCell.clear();
    }
};

class GdsDriverDataBase
{
    public:
        virtual void add_gds_lib(GdsLib const&) = 0;
};

class GdsDriver : public GdsDataBase
{
    public:
        typedef GdsDataBase base_type;
        typedef GdsDriverDataBase database_type;

        GdsDriver(database_type&);

        bool operator()(string const& filename);
 
    protected:
        virtual void bit_array_cbk(const char* ascii_record_type, const char* ascii_data_type, vector<int> const& vBitArray);
        virtual void integer_2_cbk(const char* ascii_record_type, const char* ascii_data_type, vector<int> const& vInteger);
        virtual void integer_4_cbk(const char* ascii_record_type, const char* ascii_data_type, vector<int> const& vInteger);
        virtual void real_4_cbk(const char* ascii_record_type, const char* ascii_data_type, vector<double> const& vFloat);
        virtual void real_8_cbk(const char* ascii_record_type, const char* ascii_data_type, vector<double> const& vFloat);
        virtual void string_cbk(const char* ascii_record_type, const char* ascii_data_type, string const& str);
        virtual void begin_end_cbk(const char* ascii_record_type); // begin or end indicater of a block 
        template <typename ContainerType>
        void general_cbk(string const& ascii_record_type, string const& ascii_data_type, ContainerType const& vData);
 
        database_type& m_db; 
        GdsLib m_lib; 
        string m_current; 
};
 
template <typename ContainerType>
void GdsDriver::general_cbk(string const& ascii_record_type, string const&, ContainerType const& vData)
{
    if (ascii_record_type == "HEADER")
    {
        m_current = "HEADER";
    }
    else if (ascii_record_type == "BGNLIB")
    {
        m_current = "LIBRARY";
    }
    else if (ascii_record_type == "LIBNAME")
    {
        m_lib.lib_name.assign(vData.begin(), vData.end());
    }
    else if (ascii_record_type == "UNITS")
    {
        m_lib.unit[0] = vData[0]; 
        m_lib.unit[1] = vData[1]; 
    }
    else if (ascii_record_type == "BGNSTR")
    {
        m_current = "CELL";
        m_lib.vCell.push_back(GdsCell());
    }
    else if (ascii_record_type == "STRNAME")
    {
        m_lib.vCell.back().cell_name.assign(vData.begin(), vData.end());
    }
    else if (ascii_record_type == "BOUNDARY" || ascii_record_type == "BOX") // BOUNDARY and BOX are generalized to BOUNDARY
    {
        m_current = "BOUNDARY";
        limboAssertMsg(!m_lib.vCell.empty(), "%s block must be in a BGNSTR block", ascii_record_type.c_str());
        m_lib.vCell.back().vBoundary.push_back(GdsBoundary());
    }
    else if (ascii_record_type == "TEXT")
    {
        m_current = "TEXT";
        limboAssertMsg(!m_lib.vCell.empty(), "%s block must be in a BGNSTR block", ascii_record_type.c_str());
        m_lib.vCell.back().vText.push_back(GdsText());
    }
    else if (ascii_record_type == "SREF")
    {
        m_current = "SREF";
        limboAssertMsg(!m_lib.vCell.empty(), "%s block must be in a BGNSTR block", ascii_record_type.c_str());
        m_lib.vCell.back().vSref.push_back(GdsSref());
    }
    else if (ascii_record_type == "LAYER")
    {
        if (m_current == "BOUNDARY")
            m_lib.vCell.back().vBoundary.back().layer = vData[0];
        else if (m_current == "TEXT")
            m_lib.vCell.back().vText.back().layer = vData[0];
    }
    else if (ascii_record_type == "DATATYPE") // here're some information I don't see any usage
    {
        if (m_current == "BOUNDARY")
            m_lib.vCell.back().vBoundary.back().datatype = vData[0];
    }
    else if (ascii_record_type == "TEXTTYPE")
    {
        if (m_current == "TEXT")
            m_lib.vCell.back().vText.back().texttype = vData[0];
    }
    else if (ascii_record_type == "PRESENTATION")
    {
        if (m_current == "TEXT")
            m_lib.vCell.back().vText.back().presentation = vData[0];
    }
    else if (ascii_record_type == "STRANS")
    {
        if (m_current == "TEXT")
            m_lib.vCell.back().vText.back().strans = vData[0];
    }
    else if (ascii_record_type == "MAG")
    {
        if (m_current == "TEXT")
            m_lib.vCell.back().vText.back().mag = vData[0];
    }
    else if (ascii_record_type == "SNAME")
    {
        if (m_current == "SREF")
            m_lib.vCell.back().vSref.back().sname.assign(vData.begin(), vData.end());
    }
    else if (ascii_record_type == "XY")
    {
        if (m_current == "BOUNDARY")
        {
            limboAssertMsg((vData.size() % 2) == 0 && vData.size() > 4, "invalid size of data array: %lu", vData.size());
            for (uint32_t i = 0; i < vData.size(); i += 2)
            {
                vector<int32_t> point (2);
                point[0] = vData[i];
                point[1] = vData[i+1];
                m_lib.vCell.back().vBoundary.back().vPoint.push_back(point);
            }
        }
        else if (m_current == "TEXT")
        {
            limboAssertMsg(vData.size() == 2, "invalid size of data array for %s: %lu",
                    m_current.c_str(), vData.size());
            m_lib.vCell.back().vText.back().position.assign(vData.begin(), vData.end());
        }
        else if (m_current == "SREF")
        {
            limboAssertMsg(vData.size() == 2, "invalid size of data array for %s: %lu",
                    m_current.c_str(), vData.size());
            m_lib.vCell.back().vSref.back().position.assign(vData.begin(), vData.end());
        }
        else limboAssertMsg(0, "record XY should only appear in BOUNDARY, BOX, TEXT, SREF");
    }
    else if (ascii_record_type == "STRING")
    {
        limboAssertMsg(m_current == "TEXT", "record type STRING must appear in TEXT block rather than %s", m_current.c_str());
        m_lib.vCell.back().vText.back().content.assign(vData.begin(), vData.end());
    }
    else if (ascii_record_type == "ENDEL")
    {
        limboAssertMsg(m_current == "BOUNDARY" || m_current == "TEXT"
                || m_current == "SREF", 
                "currently only support BOUNDARY, BOX, and TEXT");
        m_current = "CELL"; // go back to upper 
    }
    else if (ascii_record_type == "ENDSTR")
    {
        limboAssertMsg(m_current == "CELL", "BGNSTR and ENDSTR should be in pair");
        m_current = "LIBRARY"; // go back to upper 
    }
    else if (ascii_record_type == "ENDLIB")
    {
        limboAssertMsg(m_current == "LIBRARY", "BGNLIB and ENDLIB should be in pair");
        m_current = "HEADER"; 
        // call db 
        m_db.add_gds_lib(m_lib);
        m_lib.reset();
    }
    else limboAssertMsg(0, "unsupported record type: %s", ascii_record_type.c_str());
}

bool read(GdsDriverDataBase& db, string const& filename);
 
} // namespace GdsParser
 
#endif