oadefinpin.cpp

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

    
    pin->setPlacementStatus(placementStatus);
    polygon->addToPin(pin);
}



// *****************************************************************************
// DefInPin::parseSensitivity()
// 
// This function handles the supply and ground sensitivity attributes for the
// current pin.
// *****************************************************************************
void
DefInPin::parseSensitivity()
{
    if (defPin->hasGroundSensitivity()) {
	oaSimpleName	gndName(defIn.getNS(), defPin->groundSensitivity());
	oaBitTerm	*gndTerm = (oaBitTerm*) oaTerm::find(defIn.topBlock(),
							     gndName);
    
	term->setGroundSensitivity(gndTerm);
    }

    if (defPin->hasSupplySensitivity()) {
	oaSimpleName	vssName(defIn.getNS(), defPin->groundSensitivity());
	oaBitTerm	*vssTerm = (oaBitTerm*) oaTerm::find(defIn.topBlock(),
							     vssName);
    
	term->setGroundSensitivity(vssTerm);
    }
}



// *****************************************************************************
// DefInPin::parseNetExpr()
// 
// This function handles the NETEXPR attribute for the specified pin.
// *****************************************************************************
void
DefInPin::parseNetExpr()
{
    if (defPin->hasNetExpr()) {
	oaString    netExpr = defPin->netExpr();
	oaUInt4	    space = netExpr.substr(" ");
	
	if (space == netExpr.getLength()) {
	    defIn.error(cPinInvalidNetExpr, defPin->pinName(),
			defPin->netExpr());
	    return;
	}

	oaAssignmentDef	assign;

	netExpr[space++] = 0;
	assign.setAssignmentName(netExpr);
	
	oaString    defNet(&netExpr[space]);

	switch (defIn.getNS().getType(defNet)) {
	  case oacScalarNameType:
	    assign.setDefaultName(oaScalarName(defIn.getNS(), defNet));
	    break;

	  case oacVectorBitNameType:
	    assign.setDefaultName(oaVectorBitName(defIn.getNS(), defNet));
	    break;
	}

	oaTermConnectDef::create(term, assign);
    }
}



// *****************************************************************************
// DefInPin::parseAntenna()
// DefInPin::parseGenericAntenna()
// DefInPin::parseModelAntenna()
//
// These functions parse the antenna information on the DEF pin.
// They always stores the "generic" antenna information on the DB
// defaultAntennaModel so that it will be output by the writer.
// The generic antenna data is also stored on each of the other
// antenna models that are stored in the DB.
// *****************************************************************************
void
DefInPin::parseAntenna()
{
    if (!defPin->hasAPinPartialMetalArea()
	&& !defPin->hasAPinPartialMetalSideArea()
	&& !defPin->hasAPinDiffArea()
	&& !defPin->hasAPinPartialCutArea()
	&& !defPin->numAntennaModel()) {
	return;
    }

    // always parse generic data for defaultAntennaModel.
    oaAntennaData data(oacDefaultAntennaModel);
    if (term->isAntennaDataSet(oacDefaultAntennaModel)) {
	term->getAntennaData(data, oacDefaultAntennaModel);
    }

    parseGenericAntenna(data);
    term->setAntennaData(data);

    // parse model specific antenna data.
    for (int j=0; j < defPin->numAntennaModel(); j++) {
	oaString s(defPin->antennaModel(j)->antennaOxide());
	oaAntennaModelEnum  antennaModel(oacDefaultAntennaModel);
	if (s == "OXIDE2") {
	    antennaModel = oacSecondAntennaModel;
	} else if (s == "OXIDE3") {
	    antennaModel = oacThirdAntennaModel;
	} else if (s == "OXIDE4") {
	    antennaModel = oacFourthAntennaModel;
	}

	oaAntennaData data(antennaModel);
	if (term->isAntennaDataSet(antennaModel)) {
	    term->getAntennaData(data, antennaModel);
	}

	parseGenericAntenna(data);
	parseModelAntenna(data, oaUInt4(j));
	term->setAntennaData(data);
    }
}

void
DefInPin::parseGenericAntenna(oaAntennaData &data)
{

    oaUInt4	    i = 0;
    oaString	    layer;
    oaAntennaArea   area;

    // ANTENNAPINPARTIALMETALAREA
    oaUInt4 num = defPin->numAPinPartialMetalArea();
    if (num) {
	data.partialMetal().setSize(num, false); 
	data.partialMetal().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->APinPartialMetalArea(i);
	    layer	= defPin->APinPartialMetalAreaLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }

	    data.partialMetal().append(area);	    
	}

	data.partialMetal().compress();
    }
	
    // ANTENNAPINPARTIALMETALSIDEAREA
    num = defPin->numAPinPartialMetalSideArea();
    if (num) {
	data.partialMetalSide().setSize(num, false); 
	data.partialMetalSide().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->APinPartialMetalSideArea(i);
	    layer	= defPin->APinPartialMetalSideAreaLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }

	    data.partialMetalSide().append(area);
	}
	data.partialMetalSide().compress();
    }
	
    // ANTENNAPINDIFFAREA
    num = defPin->numAPinDiffArea();
    if (num) {
	data.diff().setSize(num, false); 
	data.diff().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->APinDiffArea(i);
	    layer	= defPin->APinDiffAreaLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }
	    
	    data.diff().append(area);
	}
	data.diff().compress();
    }


    // ANTENNAPINPARTIALCUTAREA
    num = defPin->numAPinPartialCutArea();
    if (num) {
	data.partialCut().setSize(num, false); 
	data.partialCut().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->APinPartialCutArea(i);
	    layer	= defPin->APinPartialCutAreaLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }

	    data.partialCut().append(area);
	}
	data.partialCut().compress();
    }
}

void
DefInPin::parseModelAntenna(oaAntennaData  &data,
			      oaUInt4        model)
{
    oaUInt4	    i = 0;
    oaString	    layer;
    oaAntennaArea   area;

    // ANTENNAPINGATEAREA
    oaUInt4 num(defPin->antennaModel(model)->numAPinGateArea());
    if (num) {
	data.gate().setSize(num, false); 
	data.gate().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->antennaModel(model)->APinGateArea(i);
	    layer	= defPin->antennaModel(model)->APinGateAreaLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }
	    
	    data.gate().append(area);
	}
	data.gate().compress();
    }
	    
    
    // ANTENNAPINMAXAREACAR
    num = defPin->antennaModel(model)->numAPinMaxAreaCar();
    if (num) {
	data.maxCAR().setSize(num, false); 
	data.maxCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->antennaModel(model)->APinMaxAreaCar(i);
	    layer	= defPin->antennaModel(model)->APinMaxAreaCarLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }
	    
	    data.maxCAR().append(area);
	}
	data.maxCAR().compress();
    }


    // ANTENNAPINMAXSIDEAREACAR
    num = defPin->antennaModel(model)->numAPinMaxSideAreaCar();
    if (num) {
	data.maxSideCAR().setSize(num, false); 
	data.maxSideCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->antennaModel(model)->APinMaxSideAreaCar(i);
	    layer = defPin->antennaModel(model)->APinMaxSideAreaCarLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }

	    data.maxSideCAR().append(area);
	}
	data.maxSideCAR().compress();
    }


    // ANTENNAPINMAXCUTCAR
    num = defPin->antennaModel(model)->numAPinMaxCutCar();
    if (num) {
	data.maxCutCAR().setSize(num, false); 
	data.maxCutCAR().setNumElements(0);
	for (i = 0; i < num; i++) {
	    area.area() = defPin->antennaModel(model)->APinMaxCutCar(i);
	    layer	= defPin->antennaModel(model)->APinMaxCutCarLayer(i);
	    if (!layer.isEmpty()) {
		area.layerNum() = defIn.getLayerNum(layer);
	    }

	    data.maxCutCAR().append(area);
	}
	data.maxCutCAR().compress();
    }
}



// *****************************************************************************
// DefInPin::isPhysicalOnly()
//
// This function returns true if this object should be added in case of
// doing an update of an existing logical design.
//
// - POWER/GROUND pins
// 
// - BUMP PINS might not be assigned to existing Verilog ports or OpenAccess 
//   terminals. 
// *****************************************************************************
oaBoolean
DefInPin::isPhysicalOnly()
{
    if (sigType == oacPowerSigType || sigType == oacGroundSigType
	|| sigType == oacTieoffSigType) {
	return true;
    }

    return false;
}



END_LEFDEF_NAMESPACE