349 lines
13 KiB
C++
349 lines
13 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2012-2014, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | Alliance / Hurricane Interface |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@asim.lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./PyRoutingLayerGauge.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/isobar/PyLayer.h"
|
|
#include "crlcore/PyRoutingLayerGauge.h"
|
|
#include <string>
|
|
#include <sstream>
|
|
|
|
|
|
namespace CRL {
|
|
|
|
using std::cerr;
|
|
using std::endl;
|
|
using std::hex;
|
|
using std::string;
|
|
using std::ostringstream;
|
|
using Hurricane::tab;
|
|
using Hurricane::in_trace;
|
|
using Hurricane::Error;
|
|
using Hurricane::Warning;
|
|
using Isobar::ProxyProperty;
|
|
using Isobar::ProxyError;
|
|
using Isobar::ConstructorError;
|
|
using Isobar::HurricaneError;
|
|
using Isobar::HurricaneWarning;
|
|
using Isobar::ParseOneArg;
|
|
using Isobar::ParseTwoArg;
|
|
using Isobar::__cs;
|
|
using Isobar::PyLayer;
|
|
using Isobar::PyTypeLayer;
|
|
using Isobar::PyLayer_LinkDerived;
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(RoutingLayerGauge,rlg,function)
|
|
|
|
|
|
#if defined(__PYTHON_MODULE__)
|
|
|
|
// +=================================================================+
|
|
// | "PyRoutingLayerGauge" Python Module Code Part |
|
|
// +=================================================================+
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_create ( PyObject*, PyObject* args )
|
|
{
|
|
trace << "PyRoutingLayerGauge_create()" << endl;
|
|
|
|
RoutingLayerGauge* rlg = NULL;
|
|
PyRoutingLayerGauge* pyRlg = NULL;
|
|
|
|
HTRY
|
|
PyObject* pyLayer = NULL;
|
|
int direction;
|
|
int type;
|
|
int depth;
|
|
double density;
|
|
long offset;
|
|
long pitch;
|
|
long wireWidth;
|
|
long viaWidth;
|
|
|
|
if (PyArg_ParseTuple( args
|
|
, "OIIIdllll:RoutingLayerGauge.create"
|
|
, &pyLayer
|
|
, &direction
|
|
, &type
|
|
, &depth
|
|
, &density
|
|
, &offset
|
|
, &pitch
|
|
, &wireWidth
|
|
, &viaWidth
|
|
)) {
|
|
if ( not PyObject_IsInstance(pyLayer,(PyObject*)&PyTypeLayer) ) {
|
|
PyErr_SetString ( ConstructorError, "Bad type for layer argument of RoutingLayerGauge.create()." );
|
|
return NULL;
|
|
}
|
|
switch( direction ) {
|
|
case Constant::Horizontal:
|
|
case Constant::Vertical: break;
|
|
default:
|
|
PyErr_SetString ( ConstructorError, "Bad value for direction argument of RoutingLayerGauge.create()." );
|
|
return NULL;
|
|
}
|
|
switch( type ) {
|
|
case Constant::Default:
|
|
case Constant::PinOnly: break;
|
|
default:
|
|
PyErr_SetString ( ConstructorError, "Bad value for type argument of RoutingLayerGauge.create()." );
|
|
return NULL;
|
|
}
|
|
|
|
rlg = RoutingLayerGauge::create( PYLAYER_O(pyLayer)
|
|
, direction
|
|
, type
|
|
, depth
|
|
, density
|
|
, offset
|
|
, pitch
|
|
, wireWidth
|
|
, viaWidth
|
|
);
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "Bad parameters given to RoutingLayerGauge.create()." );
|
|
return NULL;
|
|
}
|
|
|
|
pyRlg = PyObject_NEW ( PyRoutingLayerGauge, &PyTypeRoutingLayerGauge );
|
|
if ( pyRlg == NULL ) {
|
|
rlg->destroy();
|
|
return NULL;
|
|
}
|
|
|
|
pyRlg->_object = rlg;
|
|
HCATCH
|
|
|
|
return (PyObject*)pyRlg;
|
|
}
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_getLayer ( PyRoutingLayerGauge* self )
|
|
{
|
|
trace << "PyRoutingLayerGauge_getLayer()" << endl;
|
|
|
|
Layer* layer = NULL;
|
|
|
|
HTRY
|
|
METHOD_HEAD("RoutingLayerGauge.getLayer()")
|
|
layer = const_cast<Layer*>(rlg->getLayer());
|
|
HCATCH
|
|
|
|
return PyLayer_LinkDerived(layer);
|
|
}
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_getBlockageLayer ( PyRoutingLayerGauge* self )
|
|
{
|
|
trace << "PyRoutingLayerGauge_getBlockageLayer()" << endl;
|
|
|
|
Layer* layer = NULL;
|
|
|
|
HTRY
|
|
METHOD_HEAD("RoutingLayerGauge.getBlockageLayer()")
|
|
layer = const_cast<Layer*>(rlg->getBlockageLayer());
|
|
HCATCH
|
|
|
|
return PyLayer_LinkDerived(layer);
|
|
}
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_getTrackNumber ( PyRoutingLayerGauge* self, PyObject* args )
|
|
{
|
|
trace << "PyRoutingLayerGauge_getTrackNumber()" << endl;
|
|
|
|
unsigned int trackNumber = 0;
|
|
|
|
HTRY
|
|
METHOD_HEAD("RoutingLayerGauge.getTrackNumber()")
|
|
|
|
long start = 0;
|
|
long stop = 0;
|
|
|
|
if (PyArg_ParseTuple( args, "ll:RoutingLayerGauge.getTrackNumber", &start, &stop)) {
|
|
trackNumber = rlg->getTrackNumber( (DbU::Unit)start, (DbU::Unit)stop );
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "Bad parameters given to RoutingLayerGauge.getTrackNumber()." );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
return PyLong_FromLong(trackNumber);
|
|
}
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_getTrackIndex ( PyRoutingLayerGauge* self, PyObject* args )
|
|
{
|
|
trace << "PyRoutingLayerGauge_getTrackIndex()" << endl;
|
|
|
|
unsigned int trackIndex = 0;
|
|
|
|
HTRY
|
|
METHOD_HEAD("RoutingLayerGauge.getTrackIndex()")
|
|
|
|
long start = 0;
|
|
long stop = 0;
|
|
long position = 0;
|
|
long mode = 0;
|
|
|
|
if (PyArg_ParseTuple( args, "lllI:RoutingLayerGauge.getTrackIndex", &start, &stop, &position, &mode)) {
|
|
switch(mode) {
|
|
case Constant::Superior:
|
|
case Constant::Inferior:
|
|
case Constant::Nearest:
|
|
case Constant::Exact: break;
|
|
default:
|
|
PyErr_SetString ( ConstructorError, "RoutingLayerGauge.getTrackIndex(): The <mode> parameter has an invalid value ." );
|
|
return NULL;
|
|
}
|
|
trackIndex = rlg->getTrackIndex( (DbU::Unit)start
|
|
, (DbU::Unit)stop
|
|
, (DbU::Unit)position
|
|
, (unsigned int)mode );
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "Bad parameters given to RoutingLayerGauge.getTrackIndex()." );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
return Py_BuildValue("I",trackIndex);
|
|
}
|
|
|
|
|
|
static PyObject* PyRoutingLayerGauge_getTrackPosition ( PyRoutingLayerGauge* self, PyObject* args )
|
|
{
|
|
trace << "PyRoutingLayerGauge_getTrackPosition()" << endl;
|
|
|
|
DbU::Unit trackPosition = 0;
|
|
|
|
HTRY
|
|
METHOD_HEAD("RoutingLayerGauge.getTrackPosition()")
|
|
|
|
long start = 0;
|
|
unsigned int depth = 0;
|
|
|
|
if (PyArg_ParseTuple( args, "lI:RoutingLayerGauge.getTrackIndex", &start, &depth)) {
|
|
trackPosition = rlg->getTrackNumber( (DbU::Unit)start , depth);
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "Bad parameters given to RoutingLayerGauge.getTrackPosition()." );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
return PyLong_FromLong((long)trackPosition);
|
|
}
|
|
|
|
|
|
DirectGetUIntAttribute (PyRoutingLayerGauge_getDepth ,getDepth ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetUIntAttribute (PyRoutingLayerGauge_getDirection ,getDirection ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetUIntAttribute (PyRoutingLayerGauge_getType ,getType ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetDoubleAttribute(PyRoutingLayerGauge_getDensity ,getDensity ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getOffset ,getOffset ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getPitch ,getPitch ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getHalfPitch ,getHalfPitch ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getWireWidth ,getWireWidth ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getHalfWireWidth,getHalfWireWidth,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getViaWidth ,getViaWidth ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
DirectGetLongAttribute (PyRoutingLayerGauge_getHalfViaWidth ,getHalfViaWidth ,PyRoutingLayerGauge,RoutingLayerGauge)
|
|
|
|
|
|
// Standart Destroy (Attribute).
|
|
|
|
|
|
PyMethodDef PyRoutingLayerGauge_Methods[] =
|
|
{ { "create" , (PyCFunction)PyRoutingLayerGauge_create , METH_VARARGS|METH_STATIC
|
|
, "Create a new RoutingLayerGauge." }
|
|
, { "getLayer" , (PyCFunction)PyRoutingLayerGauge_getLayer , METH_NOARGS
|
|
, "Returns the associated routing layer." }
|
|
, { "getBlockageLayer" , (PyCFunction)PyRoutingLayerGauge_getBlockageLayer, METH_NOARGS
|
|
, "Returns the associated blockage layer." }
|
|
, { "getDepth" , (PyCFunction)PyRoutingLayerGauge_getDepth , METH_NOARGS
|
|
, "Returns the layer's depth in the RoutingGauge." }
|
|
, { "getDirection" , (PyCFunction)PyRoutingLayerGauge_getDirection , METH_NOARGS
|
|
, "Returns the layer's preferred routing direction." }
|
|
, { "getType" , (PyCFunction)PyRoutingLayerGauge_getType , METH_NOARGS
|
|
, "Returns the layer's type (pin only or routing)." }
|
|
, { "getDensity" , (PyCFunction)PyRoutingLayerGauge_getDensity , METH_NOARGS
|
|
, "Returns the routing track density." }
|
|
, { "getOffset" , (PyCFunction)PyRoutingLayerGauge_getOffset , METH_NOARGS
|
|
, "Returns the routing track offset (from start position)." }
|
|
, { "getPitch" , (PyCFunction)PyRoutingLayerGauge_getPitch , METH_NOARGS
|
|
, "Returns the track pitch (center to center)." }
|
|
, { "getHalfPitch" , (PyCFunction)PyRoutingLayerGauge_getHalfPitch , METH_NOARGS
|
|
, "Returns the half track pitch (center to center)." }
|
|
, { "getWireWidth" , (PyCFunction)PyRoutingLayerGauge_getWireWidth , METH_NOARGS
|
|
, "Returns the wire width." }
|
|
, { "getHalfWireWidth" , (PyCFunction)PyRoutingLayerGauge_getHalfWireWidth, METH_NOARGS
|
|
, "Returns the half wire width." }
|
|
, { "getViaWidth" , (PyCFunction)PyRoutingLayerGauge_getViaWidth , METH_NOARGS
|
|
, "Returns the VIA width." }
|
|
, { "getHalfViaWidth" , (PyCFunction)PyRoutingLayerGauge_getHalfViaWidth , METH_NOARGS
|
|
, "Returns the half VIA width." }
|
|
, { "getTrackNumber" , (PyCFunction)PyRoutingLayerGauge_getTrackNumber , METH_VARARGS
|
|
, "Compute the number of tracks included between <start> & <stop>." }
|
|
, { "getTrackIndex" , (PyCFunction)PyRoutingLayerGauge_getTrackIndex , METH_VARARGS
|
|
, "Returns the index of track at the given position (with rounding)." }
|
|
, { "getTrackPosition" , (PyCFunction)PyRoutingLayerGauge_getTrackPosition, METH_VARARGS
|
|
, "Compute the position of track number <depth>." }
|
|
//, { "destroy" , (PyCFunction)PyRoutingLayerGauge_destroy , METH_VARARGS
|
|
// , "Destroy the associated hurricane object. The python object remains." }
|
|
, {NULL, NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
PythonOnlyDeleteMethod(RoutingLayerGauge)
|
|
PyTypeObjectLinkPyType(RoutingLayerGauge)
|
|
|
|
|
|
#else // End of Python Module Code Part.
|
|
|
|
// +=================================================================+
|
|
// | "PyRoutingLayerGauge" Shared Library Code Part |
|
|
// +=================================================================+
|
|
|
|
// Type Definition.
|
|
PyTypeObjectDefinitionsOfModule(CRL,RoutingLayerGauge)
|
|
|
|
// Link/Creation Method.
|
|
LinkCreateMethod(RoutingLayerGauge)
|
|
|
|
|
|
extern void PyRoutingLayerGauge_postModuleInit ()
|
|
{
|
|
PyObject* constant;
|
|
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Horizontal ,"Horizontal");
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Vertical ,"Vertical" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Default ,"Default" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::PinOnly ,"PinOnly" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Superior ,"Superior" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Inferior ,"Inferior" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Nearest ,"Nearest" );
|
|
LoadObjectConstant(PyTypeRoutingLayerGauge.tp_dict,Constant::Exact ,"Exact" );
|
|
}
|
|
|
|
|
|
#endif // End of Shared Library Code Part.
|
|
|
|
|
|
} // extern "C".
|
|
|
|
|
|
} // CRL namespace.
|