oalefin.cpp

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

	    setConstraint(getDefaultRules(), oacValidRoutingLayers, v);
	}
    }

    if (viaDefArray.getNumElements()) {
	v = getConstraint(getDefaultRules(), oacValidRoutingVias);
	
	if (v && v->getType() == oacViaDefArrayValueType) {
	    oaViaDefArray   array;

	    ((oaViaDefArrayValue*) v)->get(array);

	    if (viaDefArray != array) {
		((oaViaDefArrayValue*) v)->set(viaDefArray);
	    }
	} else {
	    v = oaViaDefArrayValue::create(tech(), viaDefArray);
	    setConstraint(getDefaultRules(), oacValidRoutingVias, v);
	}
    }
}



// *****************************************************************************
// LefIn::postProcessLayers()
// 
// This	function does various postProcessing operations	on layers.
// At the moment:
// Remove any remaining	minimumcut rules from metal layers.
// *****************************************************************************
void
LefIn::postProcessLayers()
{
    oaIter<oaLayer> layerIter(tech()->getLayers());
    oaLayer	    *layer;
    
    while (layer = layerIter.getNext())	{
	if (layer->getType() !=	oacPhysicalLayerType) {
	    continue;
	}

	oaPhysicalLayer	*pLayer	= (oaPhysicalLayer*) layer;

	if (pLayer->getMaterial() == oacMetalMaterial) {
	    // Destroy any remaining NumCut rules on metal layers
	    oaConstraintDef *def = oaLayerConstraintDef::get(oacMinNumCut);
	    oaConstraint  *c = oaLayerConstraint::find(getFoundryRules(), 
						       layer->getNumber(),
						       (oaLayerConstraintDef*) def);

	    if (c) {
		c->destroy();
	    }
	
	    def = oaLayerConstraintDef::get(oacMinProtrusionNumCut);
	    c = oaLayerConstraint::find(getFoundryRules(), layer->getNumber(),
					(oaLayerConstraintDef*) def);
	    
	    if (c) {
		c->destroy();
	    }
	}
    }
}



// *****************************************************************************
// LefIn::close()
// 
// This	function saves and closes the technology database and the file.
// *****************************************************************************
void
LefIn::close()
{
    LefDefIn::close();
}



// *****************************************************************************
// LefIn::getLefInGeomPin()
// LefIn::getLefInGeomObs()
// LefIn::getLefInLayer()
// LefIn::getLefInMacro()
// LefIn::getLefInPin()
// LefIn::getLefInSite()
// LefIn::getLefInVia()
// LefIn::getLefInViaRule()
//
// These functions return the helper classes. If they do not exist, they are
// created here.
// *****************************************************************************
LefInGeomPin*
LefIn::getLefInGeomPin()
{
    if (!lefInGeomPin) {
	lefInGeomPin = new LefInGeomPin(*this);
    }

    return lefInGeomPin;
}

LefInGeomObs*
LefIn::getLefInGeomObs()
{
    if (!lefInGeomObs) {
	lefInGeomObs = new LefInGeomObs(*this);
    }

    return lefInGeomObs;
}

LefInLayer*
LefIn::getLefInLayer()
{
    if (!lefInLayer) {
	lefInLayer = new LefInLayer(*this);
    }

    return lefInLayer;
}

LefInMacro*
LefIn::getLefInMacro()
{
    if (!lefInMacro) {
	lefInMacro = new LefInMacro(*this);
    }

    return lefInMacro;
}

LefInNDR*
LefIn::getLefInNDR()
{
    if (!lefInNDR) {
	lefInNDR = new LefInNDR(*this);
    }

    return lefInNDR;
}

LefInPin*
LefIn::getLefInPin()
{
    if (!lefInPin) {
	lefInPin = new LefInPin(*this);
    }

    return lefInPin;
}

LefInSite*
LefIn::getLefInSite()
{
    if (!lefInSite) {
	lefInSite = new LefInSite(*this);
    }

    return lefInSite;
}

LefInVia*
LefIn::getLefInVia()
{
    if (!lefInVia) {
	lefInVia = new LefInVia(*this);
    }

    return lefInVia;
}

LefInViaRule*
LefIn::getLefInViaRule()
{
    if (!lefInViaRule) {
	lefInViaRule = new LefInViaRule(*this);
    }

    return lefInViaRule;
}



// *****************************************************************************
// LefIn::<...>CB
// 
// These static	functions are required since the CAT parser only
// accepts pointers to functions, and no pointers to member functions.
// These functions call	their virtual equivalent on the	translator class.
// *****************************************************************************
int
LefIn::cbVersion(lefrCallbackType_e	cbType,
		   double		data,
		   lefiUserData		userData)
{
    try	{
	((LefIn*) userData)->parseVersion(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbCaseSensitive(lefrCallbackType_e cbType,
			 int		    data,
			 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseCaseSensitive(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbWireExtension(lefrCallbackType_e cbType,
			 const char	    *data,
			 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseWireExtension(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbBusBitChars(lefrCallbackType_e	  cbType,
		       const char	    *data,
		       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseBusBitChars(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbDividerChar(lefrCallbackType_e	  cbType,
		       const char	    *data,
		       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseDividerChar(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbUnits(lefrCallbackType_e cbType,
		 lefiUnits	    *data,
		 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseUnits(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbManufacturingGrid(lefrCallbackType_e	cbType,
			     double		data,
			     lefiUserData	userData)
{
    try	{
	((LefIn*) userData)->parseManufacturingGrid(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbUseMinSpacing(lefrCallbackType_e cbType,
			 lefiUseMinSpacing  *data,
			 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseUseMinSpacing(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbClearanceMeasure(lefrCallbackType_e	cbType,
			    const char		*data,
			    lefiUserData	userData)
{
    try	{
	((LefIn*) userData)->parseClearanceMeasure(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbProp(lefrCallbackType_e  cbType,
		lefiProp	    *data,
		lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseProp(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbAntennaInput(lefrCallbackType_e  cbType,
			double		    data,
			lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseAntennaInput(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbAntennaOutput(lefrCallbackType_e cbType,
			 double		    data,
			 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseAntennaOutput(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbAntennaInout(lefrCallbackType_e  cbType,
			double		    data,
			lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseAntennaInout(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbInputAntenna(lefrCallbackType_e  cbType,
			double		    data,
			lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseInputAntenna(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbOutputAntenna(lefrCallbackType_e cbType,
			 double		    data,
			 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseOutputAntenna(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbInoutAntenna(lefrCallbackType_e  cbType,
			double		    data,
			lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseInoutAntenna(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbLayer(lefrCallbackType_e cbType,
		 lefiLayer	    *data,
		 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseLayer(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbMaxViaStack(lefrCallbackType_e	  cbType,
		       lefiMaxStackVia	    *data,
		       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseMaxViaStack(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbVia(lefrCallbackType_e	  cbType,
	       lefiVia		    *data,
	       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseVia(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbViaRule(lefrCallbackType_e	cbType,
		   lefiViaRule		*data,
		   lefiUserData		userData)
{
    try	{
	((LefIn*) userData)->parseViaRule(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbSpacing(lefrCallbackType_e	cbType,
		   lefiSpacing		*data,
		   lefiUserData		userData)
{
    try	{
	((LefIn*) userData)->parseSpacing(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbNonDefaultRule(lefrCallbackType_e	cbType,
			  lefiNonDefault	*ndrData,
			  lefiUserData		userData)
{
    try	{
	((LefIn*)userData)->parseNonDefaultRule(ndrData);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbSite(lefrCallbackType_e  cbType,
		lefiSite	    *data,
		lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseSite(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbMacroBegin(lefrCallbackType_e	  cbType,
		      const char	    *data,
		      lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseMacroBegin(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbMacro(lefrCallbackType_e cbType,
		 lefiMacro	    *data,
		 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseMacro(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbPin(lefrCallbackType_e	  cbType,
	       lefiPin		    *data,
	       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parsePin(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}

int
LefIn::cbObstruction(lefrCallbackType_e	  cbType,
		       lefiObstruction	    *data,
		       lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseObstruction(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}
    
int
LefIn::cbDensity(lefrCallbackType_e cbType,
		 lefiDensity	    *data,
		 lefiUserData	    userData)
{
    try	{
	((LefIn*) userData)->parseDensity(data);
    } catch (oaException    &err) {
	((LefIn*) userData)->error(cGeneric, (const char*) err.getMsg());
    }

    return PARSE_OK;
}
    


END_LEFDEF_NAMESPACE