oalefin.h

openaccess读def,lef文件所用的源代码

// *****************************************************************************
// *****************************************************************************
// LefIn.h
//
// This	file contains the definition for the LefIn class. This class
// implements reading a	LEF file and creating an OA library. It	uses the CAT
// LEF parser to parse the LEF file.
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this	material may not be copied, modified,
// re-published, uploaded, executed, or	distributed in any way,	in any medium,
// in whole or in part,	without	prior written permission from Cadence.
//
//		  Copyright 2002-2005 Cadence Design Systems, Inc.
//			     All Rights	Reserved.
//
//  $Author: sailajad $
//  $Revision: 1.66 $
//  $Date: 2005/08/05 01:41:34 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#ifndef	LefIn_P
#define	LefIn_P

#include "oaLefDef.h"
#include "lefrReader.hpp"

BEGIN_LEFDEF_NAMESPACE



// *****************************************************************************
// LefIn
// *****************************************************************************
class OA_LEFDEF_DLL_API	LefIn :	public LefDefIn	{
 public:
			    LefIn(oaUtil::MsgAdapter	&msgAdapterIn);
    virtual		    ~LefIn();

    virtual void	    run(LefInOptions	*options);
    virtual void	    run(FILE		*file,
				LefInOptions	*options);


    // Utility functions for use by helper classes.
    LefInOptions	    *getOptions()	{return options;}
    oaHierProp		    *getLegacyProp();

    void		    addLayer(oaLayerNum	layerNum);
    void		    addViaDef(oaViaDef	*viaDef);

    void		    setOverlapLayer(const oaString  &name);
    const oaString	    &getOverlapLayer()	{return	overlapLayer;}

    oaInt4		    uuToDBU(oaDouble	value);
    oaUInt4		    uuToDBUDistance(oaDouble	value);
    oaUInt8		    uuToDBUArea(oaDouble    value);
    
    virtual void	    error(LefDefMsgIds	msgId,
				  ...);
    virtual void	    warn(LefDefMsgIds	msgId,
				 ...);


    // The callback wrapper functions for the CAT parser
    static int		    cbVersion(lefrCallbackType_e    cbType,
				      double		    data,
				      lefiUserData	    userData);
    static int		    cbCaseSensitive(lefrCallbackType_e	cbType,
					    int			data,
					    lefiUserData	userData);
    static int		    cbWireExtension(lefrCallbackType_e	cbType,
					    const char		*data,
					    lefiUserData	userData);
    static int		    cbBusBitChars(lefrCallbackType_e	cbType,
					  const	char		*data,
					  lefiUserData		userData);
    static int		    cbDividerChar(lefrCallbackType_e	cbType,
					  const	char		*data,
					  lefiUserData		userData);
    static int		    cbUnits(lefrCallbackType_e	cbType,
				    lefiUnits		*data,
				    lefiUserData	userData);
    static int		    cbManufacturingGrid(lefrCallbackType_e  cbType,
						double		    data,
						lefiUserData	    userData);
    static int		    cbUseMinSpacing(lefrCallbackType_e	cbType,
					    lefiUseMinSpacing	*data,
					    lefiUserData	userData);
    static int		    cbClearanceMeasure(lefrCallbackType_e   cbType,
					       const char	    *data,
					       lefiUserData	    userData);
    static int		    cbProp(lefrCallbackType_e	cbType,
				   lefiProp		*data,
				   lefiUserData		userData);
    static int		    cbAntennaInput(lefrCallbackType_e	cbType,
					   double		data,
					   lefiUserData		userData);
    static int		    cbAntennaOutput(lefrCallbackType_e	cbType,
					    double		data,
					    lefiUserData	userData);
    static int		    cbAntennaInout(lefrCallbackType_e	cbType,
					   double		data,
					   lefiUserData		userData);
    static int		    cbInputAntenna(lefrCallbackType_e	cbType,
					   double		data,
					   lefiUserData		userData);
    static int		    cbOutputAntenna(lefrCallbackType_e	cbType,
					    double		data,
					    lefiUserData	userData);
    static int		    cbInoutAntenna(lefrCallbackType_e	cbType,
					   double		data,
					   lefiUserData		userData);
    static int		    cbLayer(lefrCallbackType_e	cbType,
				    lefiLayer		*data,
				    lefiUserData	userData);
    static int		    cbMaxViaStack(lefrCallbackType_e	cbType,
					  lefiMaxStackVia	*data,
					  lefiUserData		userData);
    static int		    cbVia(lefrCallbackType_e	cbType,
				  lefiVia		*data,
				  lefiUserData		userData);
    static int		    cbViaRule(lefrCallbackType_e    cbType,
				      lefiViaRule	    *data,
				      lefiUserData	    userData);
    static int		    cbSpacing(lefrCallbackType_e    cbType,
				      lefiSpacing	    *data,
				      lefiUserData	    userData);
    static int		    cbNonDefaultRule(lefrCallbackType_e	cbType,
					     lefiNonDefault	*ndrData,
					     lefiUserData	userData);
    static int		    cbSite(lefrCallbackType_e	cbType,
				   lefiSite		*data,
				   lefiUserData		userData);
    static int		    cbMacroBegin(lefrCallbackType_e cbType,
					 const char	    *data,
					 lefiUserData	    userData);
    static int		    cbMacro(lefrCallbackType_e	cbType,
				    lefiMacro		*data,
				    lefiUserData	userData);
    static int		    cbPin(lefrCallbackType_e	cbType,
				  lefiPin		*data,
				  lefiUserData		userData);
    static int		    cbObstruction(lefrCallbackType_e	cbType,
					  lefiObstruction	*data,
					  lefiUserData		userData);    
    static int		    cbDensity(lefrCallbackType_e    cbType,
				      lefiDensity	    *data,
				      lefiUserData	    userData);	  

 protected:
    virtual void	    parse(FILE	*file);
    virtual void	    parseVersion(double	data); 
    virtual void	    parseCaseSensitive(int  data);
    virtual void	    parseWireExtension(const char   *data);
    virtual void	    parseBusBitChars(const char	*data);
    virtual void	    parseDividerChar(const char	*data);
    virtual void	    parseUnits(lefiUnits    *data);
    virtual void	    parseManufacturingGrid(double   data);
    virtual void	    parseUseMinSpacing(lefiUseMinSpacing    *data);
    virtual void	    parseClearanceMeasure(const	char	*data);
    virtual void	    parseProp(lefiProp	*data);
    virtual void	    parseAntennaInput(double	data);
    virtual void	    parseAntennaOutput(double	data);
    virtual void	    parseAntennaInout(double	data);
    virtual void	    parseInputAntenna(double	data);
    virtual void	    parseOutputAntenna(double	data);
    virtual void	    parseInoutAntenna(double	data);
    virtual void	    parseLayer(lefiLayer    *data);
    virtual void	    parseMaxViaStack(lefiMaxStackVia	*data);
    virtual void	    parseVia(lefiVia	*data);
    virtual void	    parseViaRule(lefiViaRule	*data);
    virtual void	    parseSpacing(lefiSpacing	*data);
    virtual void	    parseNonDefaultRule(lefiNonDefault	*ndrData);
    virtual void	    parseSite(lefiSite	*data);
    virtual void	    parseMacroBegin(const char	*data);
    virtual void	    parseMacro(lefiMacro    *data);
    virtual void	    parsePin(lefiPin *data);
    virtual void	    parseObstruction(lefiObstruction	*data);	   
    virtual void	    parseDensity(lefiDensity	*data);	   

    virtual void	    init();
    virtual void	    initCallbacks();
    virtual void	    initLib();
    virtual void	    initTechDB();
    virtual void	    initConstraints();

    virtual void	    postProcessLayers();
    virtual void	    createConstraints();
    virtual void	    close();

    virtual LefInGeomPin    *getLefInGeomPin();
    virtual LefInGeomObs    *getLefInGeomObs();
    virtual LefInLayer	    *getLefInLayer();
    virtual LefInMacro	    *getLefInMacro();
    virtual LefInNDR	    *getLefInNDR();
    virtual LefInPin	    *getLefInPin();
    virtual LefInSite	    *getLefInSite();
    virtual LefInVia	    *getLefInVia();
    virtual LefInViaRule    *getLefInViaRule();

    oaString		    overlapLayer;
    oaUInt4		    dbuPerUU;
    oaHierProp		    *legacy;
    char		    techMode;
    oaBoolean		    techWarn;
    oaLayerArray	    layerArray;
    oaViaDefArray	    viaDefArray;
    oaLefNS		    lefNS;

    LefInOptions	    *options;
    LefInGeomPin	    *lefInGeomPin;
    LefInGeomObs	    *lefInGeomObs;
    LefInLayer		    *lefInLayer;
    LefInMacro		    *lefInMacro;
    LefInNDR		    *lefInNDR;
    LefInPin		    *lefInPin;
    LefInSite		    *lefInSite;
    LefInVia		    *lefInVia;
    LefInViaRule	    *lefInViaRule;

friend class LefInGeom;
friend class LefInGeomPin;
friend class LefInGeomObs;
friend class LefInLayer;
friend class LefInMacro;
friend class LefInNDR;
friend class LefInPin;
friend class LefInSite;
friend class LefInVia;
friend class LefInViaRule;
};



END_LEFDEF_NAMESPACE

#endif