oaverilogdesigndebug.cpp

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

// *****************************************************************************
// *****************************************************************************
// oaVerilogDesignDebug.cpp
//
// This file contains the member functions specific to the 
// oaDesignDebugObserver and its derived classes: oaDesignDesignObserver,
// oaDesignNetObserver, oaDesignInstObserver, oaDesignTermObserver and 
// oaDesignInstTermObserver.
//
// *****************************************************************************
// 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: shaun $
//  $Revision: 1.6 $
//  $Date: 2005/07/25 19:34:13 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#include "oaVerilogInTest.h"

// *****************************************************************************
// Initialize static members.
// *****************************************************************************
FILE		*DebugObserver::out(NULL);
oaDesign	*DebugObserver::designCache(NULL);
oaModule	*DebugObserver::moduleCache(NULL);
oaModNet	*DebugObserver::netCache(NULL);
oaModInstTerm	*DebugObserver::itermCache(NULL);
oaModTerm	*DebugObserver::termCache(NULL);
oaModInst	*DebugObserver::instCache(NULL);



// *****************************************************************************
// DebugObserver::DebugObserver
//
// This is the constructor for the DebugObserver.
// *****************************************************************************
DebugObserver::DebugObserver()
{
}



// *****************************************************************************
// DebugObserver::init
//
// This static function initializes the observers by opening the debug output 
// file.
// *****************************************************************************
void
DebugObserver::init()
{
    if (!out) {
#if defined(WIN32) 
	out = fopen("designDebug.txt", "w");
#else
	char	buf[BUFSIZ];

	sprintf(buf, "designDebug%d.txt", getpid());
	out = fopen(buf, "w");
#endif
	fprintf(out, "oaNativeNS\tns;\n");
	fprintf(out, "oaDesign\t*design;\n");
	fprintf(out, "oaModule\t*module;\n");
	fprintf(out, "oaModNet\t*net;\n");
	fprintf(out, "oaModBitNet\t*preferred;\n");
	fprintf(out, "oaModInst\t*inst;\n");
	fprintf(out, "oaModTerm\t*term;\n");
	fprintf(out, "oaModInstTerm\t*iterm;\n");
	fprintf(out, "oaModBusTermDef\t*def;\n");
	fprintf(out, "\n");
    }
}



// *****************************************************************************
// DebugObserver::getDesign
//
// This function prints a representation of the current design pointer.
// *****************************************************************************
void
DebugObserver::getDesign(oaDesign	*design,
			 const oaString	&var)
{
    if (design == designCache) {
	return;
    }

    designCache = design;

    if (!design->isValid()) {
	fprintf(out, "// invalid design\n");
	return;
    }

    oaString	lib;
    oaString	cell;
    oaString	view;

    design->getLibName(ns, lib);
    design->getCellName(ns, cell);
    design->getViewName(ns, view);

    fprintf(out, "%s = oaDesign::find(oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"));\n",
	    (const char*) var, (const char*) lib, (const char*) cell, 
	    (const char*) view);
}



// *****************************************************************************
// DebugObserver::getMaster
//
// This function prints a representation of the master of an instance.
// *****************************************************************************
void
DebugObserver::getMaster(oaModInst	*inst,
			 oaString	&master)
{
    if (!inst->isValid()) {
	fprintf(out, "// invalid instance\n");
	return;
    }

    master.resize(256);

    if (inst->isModDesignInst()) {
	oaString	lib;
	oaString	cell;
	oaString	view;

	((oaModDesignInst*) inst)->getLibName(ns, lib);
	((oaModDesignInst*) inst)->getCellName(ns, cell);
	((oaModDesignInst*) inst)->getViewName(ns, view);
	master.format("oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\")",
		     (const char*) lib, (const char*) cell, (const char*) view);
    } else {
	oaString    modName;
	
	((oaModModuleInst*) inst)->getHeader()->getName(ns, modName);
	master.format("oaScalarName(ns, \"%s\")", (const char*) modName);
    }
}



// *****************************************************************************
// DebugObserver::getModule
//
// This function prints a representation of the given module.
// *****************************************************************************
void
DebugObserver::getModule(oaModule	*module,
			 const oaString	&var)
{
    if (module == moduleCache) {
	return;
    }

    moduleCache = module;

    if (!module->isValid()) {
	fprintf(out, "// invalid module\n");
	return;
    }

    oaString	modName;

    module->getName(ns, modName);
    getDesign(module->getDesign(), "design");
    fprintf(out, "%s = oaModule::find(design, oaScalarName(ns, \"%s\"));\n", 
	    (const char*) var, (const char*) modName);
}



// *****************************************************************************
// DebugObserver::getNet
//
// This function prints a representation of the given net.
// *****************************************************************************
void
DebugObserver::getNet(oaModNet		*net,
		      const oaString	&var)
{
    if (net == netCache) {
	return;
    }

    netCache = net;

    if (!net) {
	fprintf(out, "%s = NULL;\n", (const char*) var);
	return;
    }

    if (!net->isValid()) {
	fprintf(out, "%s = NULL; // net is invalid\n", (const char*) var);
	return;
    }

    getModule(net->getModule(), "module");

    oaString	name;

    net->getName(ns, name);
    fprintf(out, "%s = oaModNet::find(module, oaName(ns, \"%s\"));\n",
	   (const char*) var, (const char*) name);
}



// *****************************************************************************
// DebugObserver::getInst
//
// This function prints a representation of the given instance.
// *****************************************************************************
void
DebugObserver::getInst(oaModInst	*inst,
		       const oaString	&var)
{
    if (inst == instCache) {
	return;
    }

    instCache = inst;

    if (!inst) {
	fprintf(out, "%s = NULL;\n", (const char*) var);
	return;
    }

    if (!inst->isValid()) {
	fprintf(out, "%s = NULL; // inst is invalid\n", (const char*) var);
	return;
    }

    getModule(inst->getModule(), "module");

    oaString	name;

    inst->getName(ns, name);
    fprintf(out, "%s = oaModInst::find(module, oaSimpleName(ns, \"%s\"));\n",
	    (const char*) var, (const char*) name);
}



// *****************************************************************************
// DebugObserver::getTerm
//
// This function prints a representation of the given term.
// *****************************************************************************
void
DebugObserver::getTerm(oaModTerm	*term,
		       const oaString	&var)
{
    if (term == termCache) {
	return;
    }

    termCache = term;

    if (!term) {
	fprintf(out, "%s = NULL;\n", (const char*) var);
	return;
    }

    if (!term->isValid()) {
	fprintf(out, "%s = NULL; // term is invalid\n", (const char*) var);
	return;
    }

    getModule(term->getModule(), "module");

    oaString	name;

    term->getName(ns, name);
    fprintf(out, "%s = oaModTerm::find(module, oaName(ns, \"%s\"));\n",
	    (const char*) var, (const char*) name);
}



// *****************************************************************************
// DebugObserver::getInstTerm
//
// This function prints a representation of the given instTerm.
// ****************************************************************************
void
DebugObserver::getInstTerm(oaModInstTerm    *iterm,
			   const oaString   &var)
{
    if (iterm == itermCache) {
	return;
    }

    itermCache = iterm;

    if (!iterm) {
	fprintf(out, "%s = NULL;\n", (const char*) var);
	return;
    }

    if (!iterm->isValid()) {
	fprintf(out, "%s = NULL; // instTerm is invalid\n", (const char*) var);
	return;
    }

    getInst(iterm->getInst(), "inst");

    if (!iterm->getInst()->isValid()) {
	return;
    }

    if (iterm->usesTermPosition()) {
	fprintf(out, "%s = oaModInstTerm::find(inst, %d);\n",
	    (const char*) var, iterm->getTermPosition());
    } else {
	oaString    name;

	iterm->getTermName(ns, name);
	fprintf(out, "%s = oaModInstTerm::find(inst, oaName(ns, \"%s\"));\n",
	        (const char*) var, (const char*) name);
    }
}


// *****************************************************************************
// DesignObserver::onFirstOpen
// DesignObserver::onPreReopen
// DesignObserver::onPurge
// DesignObserver::onPostSave
// DesignObserver::onPostSaveAs
//
// These functions print a representation of the API calls used to manipulate
// designs.
// *****************************************************************************
void
DesignObserver::onFirstOpen(oaDesign	*design)
{
    oaString	libNameStr;
    oaString	cellNameStr;
    oaString	viewNameStr;
    oaString	viewTypeStr;

    design->getLibName(ns, libNameStr);
    design->getCellName(ns, cellNameStr);
    design->getViewName(ns, viewNameStr);
    design->getViewType()->getName(viewTypeStr);

    fprintf(out, "design = oaDesign::open(oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaViewType::get(oaReservedViewType(\"%s\")), '%c'); // first open\n",
	    (const char*) libNameStr, (const char*) cellNameStr,
	    (const char*) viewNameStr, (const char*) viewTypeStr, 
	    design->getMode());
    designCache = design;
}

void
DesignObserver::onPreReopen(oaDesign	*design, 
			    oaChar	mode)
{
    oaString	libNameStr;
    oaString	cellNameStr;
    oaString	viewNameStr;

    design->getLibName(ns, libNameStr);
    design->getCellName(ns, cellNameStr);
    design->getViewName(ns, viewNameStr);

    fprintf(out, "design = oaDesign::open(oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), '%c'); // reopen (old mode = %c)\n",
	    (const char*) libNameStr, (const char*) cellNameStr,
	    (const char*) viewNameStr, mode, design->getMode());
    designCache = design;    
}

void
DesignObserver::onPurge(oaDesign    *design)
{
    getDesign(design, "design");
    fprintf(out, "design->purge();\n");
    designCache = NULL;
}

void
DesignObserver::onPostSave(oaDesign	*design, 
			   oaBoolean	succeeded)
{
    getDesign(design, "design");
    fprintf(out, "design->save(); // succeeded = %s\n",
	    succeeded ? "true" : "false");
}

void
DesignObserver::onPostSaveAs(oaDesign		*design, 
			     const oaScalarName	&libName,
			     const oaScalarName	&cellName,
			     const oaScalarName	&viewName,
			     oaBoolean		succeeded)
{
    oaString	libStr;
    oaString	cellStr;
    oaString	viewStr;

    libName.get(ns, libStr);
    cellName.get(ns, cellStr);
    viewName.get(ns, viewStr);
    getDesign(design, "design");
    fprintf(out, "design->saveAs(oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\"), oaScalarName(ns, \"%s\")); // succeeded = %s\n",
	    (const char*) libStr, (const char*) cellStr, (const char*) viewStr,
	    succeeded ? "true" : "false");
}