oadefout.cpp

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

    while (inst = instIter.getNext()) {
	oaString instName;
	inst->getName(getNS(), instName);
	outNoIndent(" %s", (const char*)instName);
    }
    
    oaCluster *parentCluster = cluster->getParent();
    if (parentCluster) {
	oaString parentName;
	parentCluster->getName(parentName);
	outNoIndent(" + REGION ");
	if ((parentName.substr("anonymous") != parentName.getLength())
            && (getOptions()->getVersion() < cLefDefVersion55)) {
	    oaIter<oaClusterBoundary>
		cbIter(parentCluster->getBoundaries());
	    oaClusterBoundary *clusterBoundary;
	    while (clusterBoundary = cbIter.getNext()) {
		oaBox bbox;
		clusterBoundary->getBBox(bbox);
		outNoIndent(" ( %i %i ) ( %i %i )",
			    bbox.left(), bbox.bottom(),
			    bbox.right(), bbox.top());
	    }
	} else {
	    outNoIndent("%s", (const char*)parentName);
	}     
    }
    incIndent();
    writeProperties(cluster, cLefDefGroup);
    decIndent();
    outNoIndent(" ;\n");
}



// *****************************************************************************
// DefOut::writeFills()
// 
// This function writes out the FILLS section of the DEF file.
// It iterates over all lpps that have shapes on purpose fill
// and calls writeFill to write the shapes for that lpp.
//
// Syntax:
// FILLS numFills ; 
//     ... 
// END FILLS 
// *****************************************************************************
void
DefOut::writeFills()
{
    oaUInt4		numFillLayers(0);
    oaIter<oaLPPHeader> lppHeaderIter(topBlock()->getLPPHeaders());
    oaLPPHeader		*lppHeader;
    while (lppHeader = lppHeaderIter.getNext()) {
	if (lppHeader->getPurposeNum() == oavPurposeNumberFill
	    && lppHeader->getShapes().getCount()) {
	    numFillLayers++;
	}
    }

    if (!numFillLayers) {
	return;
    }
    
    output("FILLS %i ;\n", numFillLayers);
    lppHeaderIter.reset();
    while (lppHeader = lppHeaderIter.getNext()) {
	if (lppHeader->getPurposeNum() == oavPurposeNumberFill
	    && lppHeader->getShapes().getCount()) {
	    writeFill(lppHeader);
	}
    }
    output("END FILLS\n\n");
}



// *****************************************************************************
// DefOut::writeFill()
// 
// This function writes out all FILL rectangles for the specified lpp
// (Note: this lpp is assumed to have the "fill" purpose - not checked)
//
// Syntax:
//     - { LAYER layerName 
//             RECT pt pt 
//             [RECT pt pt] ... ; } 
// *****************************************************************************
void
DefOut::writeFill(oaLPPHeader *lppHeader)
{
    oaLayer	*layer = getLayer(lppHeader->getLayerNum());
    oaString	layerName;
    layer->getName(layerName);
    output("- LAYER %s", (const char *) layerName);
    incIndent();

    oaIter<oaShape> shapeIter(lppHeader->getShapes());
    while (oaShape *shape = shapeIter.getNext()) {
	if (shape->getNet()) {
	    continue;
	}
	
	oaBox bBox;
	shape->getBBox(bBox);
	outNoIndent("\n");
	output("RECT ( %i %i ) ( %i %i )",
	       bBox.left(), bBox.bottom(), bBox.right(), bBox.top());
    }
    outNoIndent(" ;\n");
    decIndent();
}



// *****************************************************************************
// DefOut::writeEnd()
// 
// This function writes a DEF END DESIGN statement
// *****************************************************************************
void
DefOut::writeEnd()
{
    output("END DESIGN\n");
}



// *****************************************************************************
// DefOut::writeProperties()
// 
// This function writes DEF PROPERTIES for the given object.
//
// Syntax:
// [+ PROPERTY propName propVal]...
// *****************************************************************************
void
DefOut::writeProperties(oaObject		*o,
			  LefDefObjectEnum	objectType)
{
    oaProp	    *prop;
    oaString	    propName;
    oaString	    propValue;
    oaIter<oaProp>  propIter(o->getProps());

    while (prop = propIter.getNext()) {
	prop->getName(propName);
	
	if (findProp(propName, objectType)) {
	    prop->getValue(propValue);
	    
	    if (prop->getType() == oacStringPropType) {
		// Check the value is valid in the LEF/DEF namespace.
		if (strchr(propValue, '\n') || strchr(propValue, '#')) {
		    continue;
		}

		outNoIndent("\n");
		output("+ PROPERTY %s \"%s\"",
		       (const char*)propName, (const char*)propValue);
	    } else {
		outNoIndent("\n");
		output("+ PROPERTY %s %s",
		       (const char*)propName, (const char*)propValue);
	    }
	}
    }
}



// *****************************************************************************
// DefOut::writeRect()
// DefOut::writePolygon()
// 
// These functions write DEF geometry
// *****************************************************************************
static oaInt4 
intcmp(const oaInt4 *a1, 
       const oaInt4 *a2)
{
    if (*a1 > *a2) {
	return 1;
    } else if (*a1 == *a2) {
	return 0;
    } else {
	return -1;
    }
}

void
DefOut::writeRect(const oaBox	&box)
{
    outNoIndent("\n");
    output("RECT ( %i %i ) ( %i %i )",
	box.left(),  box.bottom(), box.right(), box.top());
}

void
DefOut::writeRect(const oaPointArray	&pointArray)
{
    if (pointArray.isRectangle()) {
	oaBox box;
	
	pointArray.getBBox(box);
	return writeRect(box);
    }

    oaArray<oaInt4> xArray;
    oaArray<oaInt4> yArray;

    for (oaUInt4 i = 0; i < pointArray.getNumElements(); i++) {
	oaInt4	x = pointArray[i].x();
	oaInt4	y = pointArray[i].y();

	if (xArray.find(x) == oacNullIndex) {
	    xArray.append(x);
	}
	
	if (yArray.find(y) == oacNullIndex) {
	    yArray.append(y);
	}
    }

    xArray.sort(intcmp);
    yArray.sort(intcmp);

    for (oaUInt4 i = 1; i < xArray.getNumElements(); i++) {
	oaBox box;
	
	box.left() = xArray[i - 1];
	box.right() = xArray[i];

	for (oaUInt4 j = 1; j < yArray.getNumElements(); j++) {
	    box.bottom() = yArray[j - 1];
	    box.top() = yArray[j];

	    if (pointArray.contains(box)) {
		writeRect(box);
	    }
	}
    }
}

void
DefOut::writePolygon(const oaPointArray	&pointArray)
{
    if (pointArray.isRectangle()
	|| getOptions()->getVersion() < cLefDefVersion56) {
	return writeRect(pointArray);
    }
    
    outNoIndent("\n");
    output("POLYGON");
    for (oaUInt4 i = 0; i < pointArray.getNumElements(); i++) {
	outNoIndent(" ( %i %i )", pointArray[i].x(), pointArray[i].y());
    }
}



// *****************************************************************************
// DefOut::initDesign()
//
// This function finds the specified design
// *****************************************************************************
void
DefOut::initDesign()
{
    design() = oaDesign::open(options->getLibName(), options->getCellName(),
			      options->getViewName(), 'r');
}



// *****************************************************************************
// DefOut::initNameSpace()
//
// Sets busbit & divider chars in the current def namespace
// note: these chars are currently stored as string properties
// *****************************************************************************
void
DefOut::initNameSpace()
{
    oaHierProp *legacy = (oaHierProp *) oaProp::find(tech(), cLefLegacyProp);
    if (legacy) {
	oaStringProp *prop
	    = (oaStringProp *) oaProp::find(legacy,
					    cLefBusBitChars);
	if (prop) {
	    oaString busBitChars;
	    prop->getValue(busBitChars);
	    defNS.setOpenBusChar(busBitChars[(oaUInt4) 0]);
	    defNS.setCloseBusChar(busBitChars[(oaUInt4) 1]);
	}
	
	prop = (oaStringProp *) oaProp::find(legacy,
					     cLefDividerChar);
	if (prop) {
	    oaString	dividerChar;
	    ((oaStringProp*) prop)->getValue(dividerChar);
	    defNS.setHierDelimiter(dividerChar[(oaUInt4) 0]);
	}
    }
}



// *****************************************************************************
// DefOut::initPropDefs()
//
// This function collects the list of property definitions found in the
// design database. This includes the properties on all DEF objects that
// will be output.
// Unfortunately, since property definitions are currently not
// stored, we have to search through ALL the database for defined
// properties... SLOW
// *****************************************************************************
void
DefOut::initPropDefs()
{
    oaProp* prop;
    
    // DESIGN property definitions
    oaIter<oaProp> designPropIter(design()->getProps());
    while (prop = designPropIter.getNext()) {
	oaString name;
	prop->getName(name);
	if (name != cDefTechnology) {
	    addProp(prop, cLefDefDesign);
	}
    }
    
    // COMPONENT property definitions
    oaIter<oaInst> instIter(topBlock()->getInsts());
    oaInst *inst;
    while (inst = instIter.getNext()) {

	oaIter<oaProp> instPropIter(inst->getProps());
	while (prop = instPropIter.getNext()) {
	    addProp(prop, cLefDefComponent);
	}
	
	// COMPONENTPIN property definitions on InstTerms
	oaIter<oaInstTerm>  instTermIter(inst->getInstTerms(oacInstTermIterSingleBit | oacInstTermIterEquivNets));
	oaInstTerm	    *instTerm;
	while (instTerm = instTermIter.getNext()) {
	    oaIter<oaProp> instTermPropIter(instTerm->getProps());
	    while (prop = instTermPropIter.getNext()) {
		addProp(prop, cLefDefComponentPin);
	    }
	}
	    
    }
    
    // COMPONENTPIN property definitions on Terminals
    oaIter<oaTerm>  termIter(topBlock()->getTerms(oacTermIterSingleBit
						  | oacTermIterEquivNets));
    oaTerm	    *term;

    while (term = termIter.getNext()) {
	oaIter<oaProp> termPropIter(term->getProps());
	while (prop = termPropIter.getNext()) {
	    addProp(prop, cLefDefComponentPin);
	}
	
    }
    
    // (SPECIAL)NET property definitions
    oaIter<oaNet>   netIter(topBlock()->getNets(oacNetIterSingleBit
						| oacNetIterPreferred));
    oaBitNet	    *net;

    while (net = (oaBitNet*) netIter.getNext()) {
	oaSigType sigType = net->getSigType();
	
	if (!defOutNet) {
	    new DefOutNet(*this);
	}

	if (defOutNet->hasData(net)) {
	    // NET property definitions
	    oaIter<oaProp> netPropIter(net->getProps());
	    while (prop = netPropIter.getNext()) {
		oaString    name;
		prop->getName(name);
		if (name != cDefEstCap
		    && name != cDefFrequency
		    && name != cDefXtalk) {
		    addProp(prop, cLefDefNet);
		}
	    }
	} else {
	    // SPECIALNET property definitions
	    oaIter<oaProp> netPropIter(net->getProps());
	    while (prop = netPropIter.getNext()) {
		oaString    name;
		prop->getName(name);
		if (name != cDefEstCap) {
		    addProp(prop, cLefDefSpecialNet);
		}
	    }
	}
    }
    
    
    // GROUP/REGION property definitions
    oaIter<oaCluster> clusterIter(topBlock()->getClusters());
    oaCluster *cluster;
    while (cluster = clusterIter.getNext()) {
	if (!cluster->getBoundaries().getCount()) {
	    // GROUP property
	    oaIter<oaProp> groupPropIter(cluster->getProps());
	    while (prop = groupPropIter.getNext()) {
		addProp(prop, cLefDefGroup);
	    }
	} else {
	    // REGION property
	    oaIter<oaProp> regionPropIter(cluster->getProps());
	    while (prop = regionPropIter.getNext()) {
		addProp(prop, cLefDefRegion);
	    }
	    
	}
    }

    // ROW property definitions
    oaIter<oaRow> rowIter(topBlock()->getRows());
    oaRow *row;
    while (row = rowIter.getNext()) {
	oaIter<oaProp> rowPropIter(row->getProps());
	while (prop = rowPropIter.getNext()) {
	    addProp(prop, cLefDefRow);
	}
    }

    // NONDEFAULTRULE property definitions
    oaIter<oaConstraintGroup>   cgIter(design()->getConstraintGroups());
    oaSimpleConstraintDef	*def = oaSimpleConstraintDef::get(oacValidRoutingLayers);

    while (oaConstraintGroup *cg = cgIter.getNext()) {
	oaIter<oaConstraintGroupMem> cgmIter(cg->getMembers());

	while (oaConstraintGroupMem *cgm = cgmIter.getNext()) {
	    if (cgm->getObject()->getType() == oacSimpleConstraintType) {
		if (((oaSimpleConstraint*) cgm->getObject())->getDef() == def) {
		    oaIter<oaProp> cgPropIter(cg->getProps());

		    while (prop = cgPropIter.getNext()) {
			addProp(prop, cLefDefNonDefaultRule);
		    }
		}
	    }
	}
    }
}



// *****************************************************************************
// DefOut::close()
// 
// Closes the desigfn and technology database.
// *****************************************************************************
void
DefOut::close()
{
    design()->close();
    
    LefDefOut::close();
}



END_LEFDEF_NAMESPACE