oaverilogdesigndebug.h

openaccess与verilog互相转化时所用的源代码

// *****************************************************************************
// *****************************************************************************
// oaVerilogDesignDebug.h
//
// This file contains the definition of	the DesignDebug class and its
// associated classes. These classes implement observers on the OA design
// database that track changes which occur as the design is being read by the
// translator. These observers are an aid to debugging translation issues.
//
// *****************************************************************************
// 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	istributed in any way, in any medium,
// in whole or in part,	without	prior written permission from Cadence.
//
//		  Copyright 2003-2005 Cadence Design	Systems, Inc.
//			     All Rights	Reserved.
//
//  $Author: shaun $
//  $Revision: 1.3 $
//  $Date: 2005/07/25 18:44:42 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#ifndef	oaVerilogDesignDebug_P
#define	oaVerilogDesignDebug_P

// *****************************************************************************
// DebugObserver
// *****************************************************************************
class DebugObserver {
  public:
    static void		    init();

  protected:
			    DebugObserver();

    void		    getDesign(oaDesign		*design,
				      const oaString	&var);
    void		    getMaster(oaModInst	*inst,
				      oaString	&master);
    void		    getModule(oaModule		*module,
				      const oaString	&var);
    void		    getNet(oaModNet	    *net,
				   const oaString   &var);
    void		    getInst(oaModInst	    *inst,
				    const oaString  &var);
    void		    getTerm(oaModTerm	    *term,
				    const oaString  &var);
    void		    getInstTerm(oaModInstTerm	*iterm,
					const oaString	&var);

    oaNativeNS		    ns;

    static oaDesign	    *designCache;
    static oaModule	    *moduleCache;
    static oaModNet	    *netCache;
    static oaModInstTerm    *itermCache;
    static oaModTerm	    *termCache;
    static oaModInst	    *instCache;
    static FILE		    *out;
};



// *****************************************************************************
// oaDesignDesignObserver
// *****************************************************************************
class DesignObserver : public oaObserver<oaDesign>,
		       public DebugObserver {
public:
			    DesignObserver() : oaObserver<oaDesign>(1, false) {}

     virtual void	    onFirstOpen(oaDesign    *design);
     virtual void	    onPreReopen(oaDesign    *design, 
					oaChar	    mode);
     virtual void	    onPurge(oaDesign *design);
     virtual void	    onPostSave(oaDesign	    *design, 
				       oaBoolean    succeeded);
     virtual void	    onPostSaveAs(oaDesign	    *design, 
					 const oaScalarName &libName,
					 const oaScalarName &cellName,
					 const oaScalarName &viewName,
					 oaBoolean	    succeeded);
};



// *****************************************************************************
// ModuleObserver
// *****************************************************************************
class ModuleObserver : public oaObserver<oaModule>,
		       public DebugObserver {
public:
			    ModuleObserver() : oaObserver<oaModule>(1, false) {}

    virtual void	    onPostCreate(oaModule   *module);
    virtual void	    onPostModify(oaModule		*module, 
					 oaModuleModTypeEnum	modType);
    virtual void	    onPreDestroy(oaModule   *module);
};



// *****************************************************************************
// NetObserver
// *****************************************************************************
class NetObserver : public oaObserver<oaModNet>,
		    public DebugObserver {
public:
			    NetObserver() : oaObserver<oaModNet>(1, false) {}

    virtual void	    onPostCreate(oaModNet   *net);
    virtual void	    onPostModify(oaModNet	    *net, 
					 oaNetModTypeEnum   modType);
    virtual void	    onPreDestroy(oaModNet   *net);
};



// *****************************************************************************
// BusNetDefObserver
// *****************************************************************************
class BusNetDefObserver : public oaObserver<oaModBusNetDef>,
			  public DebugObserver {
public:
			    BusNetDefObserver() : oaObserver<oaModBusNetDef>(1, false) {}

    virtual void	    onPostCreate(oaModBusNetDef	*def);
    virtual void	    onPostModify(oaModBusNetDef		*def, 
					 oaBusNetDefModTypeEnum	modType);
    virtual void	    onPreDestroy(oaModBusNetDef	*def);
};



// *****************************************************************************
// InstTermObserver
// *****************************************************************************
class InstTermObserver : public oaObserver<oaModInstTerm>,
			 public DebugObserver {
public:
			    InstTermObserver() : oaObserver<oaModInstTerm>(1, false) {}

    virtual void	    onPostCreate(oaModInstTerm	*iterm);
    virtual void	    onPostModify(oaModInstTerm		*iterm,	
					 oaInstTermModTypeEnum	modType);
    virtual void	    onPreDestroy(oaModInstTerm	*iterm);
};



// *****************************************************************************
// InstObserver
// *****************************************************************************
class InstObserver : public oaObserver<oaModInst>,
		     public DebugObserver {
public:
			    InstObserver() : oaObserver<oaModInst>(1, false) {}

    virtual void	    onPostCreate(oaModInst  *inst);
    virtual void	    onPostModify(oaModInst	    *inst, 
					 oaInstModTypeEnum  modType);
    virtual void	    onPreDestroy(oaModInst  *inst);
};



// *****************************************************************************
// TermObserver
// *****************************************************************************
class TermObserver : public oaObserver<oaModTerm>,
		     public DebugObserver {
public:
			    TermObserver() : oaObserver<oaModTerm>(1, false) {}

    virtual void	    onPostCreate(oaModTerm  *term);
    virtual void	    onPostModify(oaModTerm	    *term, 
					 oaTermModTypeEnum  modType);
    virtual void	    onPreDestroy(oaModTerm  *term);
};



// *****************************************************************************
// BusTermDefObserver
// *****************************************************************************
class BusTermDefObserver : public oaObserver<oaModBusTermDef>,
			   public DebugObserver {
public:
			    BusTermDefObserver() : oaObserver<oaModBusTermDef>(1, false) {}

    virtual void	    onPostCreate(oaModBusTermDef    *def);
    virtual void	    onPostModify(oaModBusTermDef	    *def, 
					 oaBusTermDefModTypeEnum    modType);
    virtual void	    onPreDestroy(oaModBusTermDef    *def);
};



#endif