LefDataBase.h

Go to the documentation of this file.

 
#ifndef LEFPARSER_DATABASE_H
#define LEFPARSER_DATABASE_H
 
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cassert>
#include <limbo/thirdparty/lefdef/5.8/lef/lef/lefrReader.hpp>
#include <limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.hpp>
#include <limbo/thirdparty/lefdef/5.8/lef/lef/lefiDebug.hpp>
#include <limbo/thirdparty/lefdef/5.8/lef/lef/lefiEncryptInt.hpp>
#include <limbo/thirdparty/lefdef/5.8/lef/lef/lefiUtil.hpp>

namespace LefParser {

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 LefDefParser::lefiArrayFloorPlan lefiArrayFloorPlan;
typedef LefDefParser::lefiArray lefiArray;
typedef LefDefParser::lefiNoiseVictim lefiNoiseVictim;
typedef LefDefParser::lefiNoiseResistance lefiNoiseResistance;
typedef LefDefParser::lefiNoiseEdge lefiNoiseEdge;
typedef LefDefParser::lefiNoiseTable lefiNoiseTable;
typedef LefDefParser::lefiCorrectionVictim lefiCorrectionVictim;
typedef LefDefParser::lefiCorrectionResistance lefiCorrectionResistance;
typedef LefDefParser::lefiCorrectionEdge lefiCorrectionEdge;
typedef LefDefParser::lefiCorrectionTable lefiCorrectionTable;
typedef LefDefParser::lefiAntennaPWL lefiAntennaPWL;
typedef LefDefParser::lefiLayerDensity lefiLayerDensity;
typedef LefDefParser::lefiParallel lefiParallel;
typedef LefDefParser::lefiInfluence lefiInfluence;
typedef LefDefParser::lefiTwoWidths lefiTwoWidths;
typedef LefDefParser::lefiSpacingTable lefiSpacingTable;
typedef LefDefParser::lefiOrthogonal lefiOrthogonal;
typedef LefDefParser::lefiAntennaModel lefiAntennaModel;
typedef LefDefParser::lefiLayer lefiLayer;
typedef LefDefParser::lefiObstruction lefiObstruction;
typedef LefDefParser::lefiPinAntennaModel lefiPinAntennaModel;
typedef LefDefParser::lefiPin lefiPin;
typedef LefDefParser::lefiDensity lefiDensity;
typedef LefDefParser::lefiMacro lefiMacro;
typedef LefDefParser::lefiTiming lefiTiming;
typedef LefDefParser::lefiGeometries lefiGeometries;
typedef LefDefParser::lefiSpacing lefiSpacing;
typedef LefDefParser::lefiIRDrop lefiIRDrop;
typedef LefDefParser::lefiMinFeature lefiMinFeature;
typedef LefDefParser::lefiSite lefiSite;
typedef LefDefParser::lefiSitePattern lefiSitePattern;
typedef LefDefParser::lefiTrackPattern lefiTrackPattern;
typedef LefDefParser::lefiGcellPattern lefiGcellPattern;
typedef LefDefParser::lefiUseMinSpacing lefiUseMinSpacing;
typedef LefDefParser::lefiMaxStackVia lefiMaxStackVia;
typedef LefDefParser::lefiNonDefault lefiNonDefault;
typedef LefDefParser::lefiProp lefiProp;
typedef LefDefParser::lefiPropType lefiPropType;
typedef LefDefParser::lefiUnits lefiUnits;
typedef LefDefParser::lefiViaLayer lefiViaLayer;
typedef LefDefParser::lefiVia lefiVia;
typedef LefDefParser::lefiViaRuleLayer lefiViaRuleLayer;
typedef LefDefParser::lefiViaRule lefiViaRule;
 
typedef LefDefParser::lefiNoiseMargin lefiNoiseMargin;
typedef LefDefParser::lefiGeomRect lefiGeomRect;
typedef LefDefParser::lefiGeomRectIter lefiGeomRectIter;
typedef LefDefParser::lefiGeomPath lefiGeomPath;
typedef LefDefParser::lefiGeomPathIter lefiGeomPathIter;
typedef LefDefParser::lefiGeomPolygon lefiGeomPolygon;
typedef LefDefParser::lefiGeomPolygonIter lefiGeomPolygonIter;
typedef LefDefParser::lefiGeomVia lefiGeomVia;
typedef LefDefParser::lefiGeomViaIter lefiGeomViaIter;
typedef LefDefParser::lefiPoints lefiPoints;
 
enum lefiGeomEnum {
  lefiGeomUnknown = LefDefParser::lefiGeomUnknown,
  lefiGeomLayerE = LefDefParser::lefiGeomLayerE,
  lefiGeomLayerExceptPgNetE = LefDefParser::lefiGeomLayerExceptPgNetE,
  lefiGeomLayerMinSpacingE = LefDefParser::lefiGeomLayerMinSpacingE,
  lefiGeomLayerRuleWidthE = LefDefParser::lefiGeomLayerRuleWidthE,
  lefiGeomWidthE = LefDefParser::lefiGeomWidthE,
  lefiGeomPathE = LefDefParser::lefiGeomPathE,
  lefiGeomPathIterE = LefDefParser::lefiGeomPathIterE,
  lefiGeomRectE = LefDefParser::lefiGeomRectE,
  lefiGeomRectIterE = LefDefParser::lefiGeomRectIterE,
  lefiGeomPolygonE = LefDefParser::lefiGeomPolygonE,
  lefiGeomPolygonIterE = LefDefParser::lefiGeomPolygonIterE,
  lefiGeomViaE = LefDefParser::lefiGeomViaE,
  lefiGeomViaIterE = LefDefParser::lefiGeomViaIterE,
  lefiGeomClassE = LefDefParser::lefiGeomClassE,
  lefiGeomEnd = LefDefParser::lefiGeomEnd
};
 
// forward declaration
class LefDataBase
{
    public:
        LefDataBase();
        double current_version() const;
        void current_version(double cv);
 
        // Although it is true that I can use pure virtual functions for all callbacks, 
        // run-time information is better than compile-time errors.
        // Because most LEF files are so simple that we only need several callbacks.  
        // Then user does not need to provide some callbacks.

        virtual void lef_version_cbk(string const& v)
        {
            cout << "LEF version: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }

        virtual void lef_version_cbk(double v);
        virtual void lef_dividerchar_cbk(string const& v)
        {
            cout << "LEF dividerchar: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }

        virtual void lef_casesensitive_cbk(int v);
        virtual void lef_nowireextension_cbk(string const& v)
        {
            cout << "LEF nowireextension: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }

        virtual void lef_manufacturing_cbk(double v);
        virtual void lef_useminspacing_cbk(lefiUseMinSpacing const& v);
        virtual void lef_clearancemeasure_cbk(string const& v)
        {
            cout << "LEF clearancemeasure: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }

        virtual void lef_units_cbk(lefiUnits const& v);
        virtual void lef_busbitchars_cbk(string const& v)
        {
            cout << "LEF busbitchars: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }

        virtual void lef_layer_cbk(lefiLayer const& v);
        virtual void lef_maxstackvia_cbk(lefiMaxStackVia const& v);
        virtual void lef_via_cbk(lefiVia const& v);
        virtual void lef_viarule_cbk(lefiViaRule const& v);
        virtual void lef_spacing_cbk(lefiSpacing const& v);
        virtual void lef_irdrop_cbk(lefiIRDrop const& v);
        virtual void lef_minfeature_cbk(lefiMinFeature const& v);
        virtual void lef_dielectric_cbk(double v);
        virtual void lef_nondefault_cbk(lefiNonDefault const& v);
        virtual void lef_site_cbk(lefiSite const& v);
        virtual void lef_macrobegin_cbk(std::string const& v)
        {
            cout << "macro begin " << v << endl; 
            lef_user_cbk_reminder(__func__); 
        }

        virtual void lef_macro_cbk(lefiMacro const& v);
        virtual void lef_pin_cbk(lefiPin const& v);
        virtual void lef_obstruction_cbk(lefiObstruction const& v);
        virtual void lef_density_cbk(lefiDensity const& v);
        virtual void lef_timing_cbk(lefiTiming const& v);
        virtual void lef_array_cbk(lefiArray const& v);
        virtual void lef_prop_cbk(lefiProp const& v);
        virtual void lef_noisemargin_cbk(lefiNoiseMargin const& v);
        virtual void lef_edgeratethreshold1_cbk(double v);
        virtual void lef_edgeratethreshold2_cbk(double v);
        virtual void lef_edgeratescalefactor_cbk(double v);
        virtual void lef_noisetable_cbk(lefiNoiseTable const& v);
        virtual void lef_correctiontable_cbk(lefiCorrectionTable const& v);
        virtual void lef_inputantenna_cbk(double v);
        virtual void lef_outputantenna_cbk(double v);
        virtual void lef_inoutantenna_cbk(double v);
        virtual void lef_antennainput_cbk(double v);
        virtual void lef_antennaoutput_cbk(double v);
        virtual void lef_antennainout_cbk(double v);
        virtual void lef_extension_cbk(string const& v)
        {
            cout << "LEF extension: " << v << endl;
            lef_user_cbk_reminder(__func__);
        }
    protected:
        double m_current_version; 
    public:
        static int lefNamesCaseSensitive; 
        static int lefrShiftCase; 
    private:
        void lef_user_cbk_reminder(const char* str) const;
};
 
} // namespace LefParser
 
#endif