887 lines
39 KiB
C++
887 lines
39 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2008-2018, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | I s o b a r - Hurricane / Python Interface |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./PyHurricane.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/isobar/PyHurricane.h"
|
|
#include "hurricane/isobar/PyBreakpoint.h"
|
|
#include "hurricane/isobar/PyDebugSession.h"
|
|
#include "hurricane/isobar/PyUpdateSession.h"
|
|
#include "hurricane/isobar/PyDbU.h"
|
|
#include "hurricane/isobar/PyPoint.h"
|
|
#include "hurricane/isobar/PyPointCollection.h"
|
|
#include "hurricane/isobar/PyInterval.h"
|
|
#include "hurricane/isobar/PyBox.h"
|
|
#include "hurricane/isobar/PyTransformation.h"
|
|
#include "hurricane/isobar/PyOrientation.h"
|
|
#include "hurricane/isobar/PyDataBase.h"
|
|
#include "hurricane/isobar/PyLibrary.h"
|
|
#include "hurricane/isobar/PyEntity.h"
|
|
#include "hurricane/isobar/PyCell.h"
|
|
#include "hurricane/isobar/PyCellCollection.h"
|
|
#include "hurricane/isobar/PyLayer.h"
|
|
#include "hurricane/isobar/PyLayerMask.h"
|
|
#include "hurricane/isobar/PyMaterial.h"
|
|
#include "hurricane/isobar/PyBasicLayer.h"
|
|
#include "hurricane/isobar/PyRegularLayer.h"
|
|
#include "hurricane/isobar/PyContactLayer.h"
|
|
#include "hurricane/isobar/PyDiffusionLayer.h"
|
|
#include "hurricane/isobar/PyTransistorLayer.h"
|
|
#include "hurricane/isobar/PyViaLayer.h"
|
|
#include "hurricane/isobar/PyLayerCollection.h"
|
|
#include "hurricane/isobar/PyBasicLayerCollection.h"
|
|
#include "hurricane/isobar/PyRegularLayerCollection.h"
|
|
#include "hurricane/isobar/PyViaLayerCollection.h"
|
|
#include "hurricane/isobar/PyPin.h"
|
|
#include "hurricane/isobar/PyPinPlacementStatus.h"
|
|
#include "hurricane/isobar/PyPinDirection.h"
|
|
#include "hurricane/isobar/PyPinCollection.h"
|
|
#include "hurricane/isobar/PyRoutingPadCollection.h"
|
|
#include "hurricane/isobar/PyPlacementStatus.h"
|
|
#include "hurricane/isobar/PyInstance.h"
|
|
#include "hurricane/isobar/PyInstanceCollection.h"
|
|
#include "hurricane/isobar/PyReference.h"
|
|
#include "hurricane/isobar/PyReferenceCollection.h"
|
|
#include "hurricane/isobar/PyNet.h"
|
|
#include "hurricane/isobar/PyNetType.h"
|
|
#include "hurricane/isobar/PyNetDirection.h"
|
|
#include "hurricane/isobar/PyNetCollection.h"
|
|
#include "hurricane/isobar/PyNetExternalComponents.h"
|
|
#include "hurricane/isobar/PyNetRoutingState.h"
|
|
#include "hurricane/isobar/PyNetRoutingProperty.h"
|
|
#include "hurricane/isobar/PyHyperNet.h"
|
|
#include "hurricane/isobar/PyHook.h"
|
|
#include "hurricane/isobar/PyHookCollection.h"
|
|
#include "hurricane/isobar/PyComponent.h"
|
|
#include "hurricane/isobar/PyComponentCollection.h"
|
|
#include "hurricane/isobar/PyPlug.h"
|
|
#include "hurricane/isobar/PyPlugCollection.h"
|
|
#include "hurricane/isobar/PyRoutingPad.h"
|
|
#include "hurricane/isobar/PySegment.h"
|
|
#include "hurricane/isobar/PySegmentCollection.h"
|
|
#include "hurricane/isobar/PyContact.h"
|
|
#include "hurricane/isobar/PyHorizontal.h"
|
|
#include "hurricane/isobar/PyVertical.h"
|
|
#include "hurricane/isobar/PyPad.h"
|
|
#include "hurricane/isobar/PyDiagonal.h"
|
|
#include "hurricane/isobar/PyRectilinear.h"
|
|
#include "hurricane/isobar/PyPolygon.h"
|
|
#include "hurricane/isobar/PyPath.h"
|
|
#include "hurricane/isobar/PyOccurrence.h"
|
|
#include "hurricane/isobar/PyOccurrenceCollection.h"
|
|
#include "hurricane/isobar/PyTechnology.h"
|
|
#include "hurricane/isobar/PyQueryMask.h"
|
|
#include "hurricane/isobar/PyQuery.h"
|
|
#include "hurricane/isobar/PyDeviceDescriptor.h"
|
|
#include "hurricane/isobar/PyUnitRule.h"
|
|
#include "hurricane/isobar/PyPhysicalRule.h"
|
|
#include "hurricane/isobar/PyTwoLayersPhysicalRule.h"
|
|
#include "hurricane/NetExternalComponents.h"
|
|
#include <stddef.h>
|
|
|
|
|
|
namespace Isobar {
|
|
|
|
|
|
#if !defined(__PYTHON_MODULE__)
|
|
|
|
// +=================================================================+
|
|
// | "PyHurricane" Shared Library Code Part |
|
|
// +=================================================================+
|
|
|
|
|
|
// +-----------------------------------------------------------------+
|
|
// | "PyHurricane" C++ Local Variables |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
namespace {
|
|
|
|
using namespace std;
|
|
|
|
// ---------------------------------------------------------------
|
|
// Local Variables.
|
|
|
|
const char* objectTypeRedefinition =
|
|
"ConverterState::AddType () :\n\n"
|
|
" Attempt to add twice a type with identifier \n";
|
|
|
|
|
|
} // Anonymous namespace.
|
|
|
|
|
|
using namespace Hurricane;
|
|
|
|
|
|
// +-----------------------------------------------------------------+
|
|
// | "PyHurricane" C++ Global Variables |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
const char* ConverterState::ObjectType::_inheritStop
|
|
= "comp";
|
|
ConverterState __cs = ConverterState ();
|
|
int __objectOffset = offsetof ( PyPoint, _object );
|
|
|
|
|
|
// +-----------------------------------------------------------------+
|
|
// | "PyHurricane" C++ Functions |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::ObjectType::PyEqual ()"
|
|
|
|
bool ConverterState::ObjectType::PyEqual ( PyTypeObject* pyType )
|
|
{
|
|
if ( _pyType == pyType ) return true;
|
|
if ( _idBase[0] == '\0' ) return false;
|
|
return ( __cs.getObject(_idBase)->PyEqual(pyType) );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::ObjectType::PyBase ()"
|
|
|
|
ConverterState::ObjectType* ConverterState::ObjectType::PyBase ( PyTypeObject* pyType )
|
|
{
|
|
if ( _pyType != pyType ) return NULL;
|
|
return ( PyBase() );
|
|
}
|
|
|
|
|
|
ConverterState::ObjectType* ConverterState::ObjectType::PyBase ()
|
|
{
|
|
if ( _idBase[0] == '\0' ) return this;
|
|
if ( ! strcmp(_id,_inheritStop) ) return this;
|
|
return ( __cs.getObject(_idBase)->PyBase() );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::ObjectType::PyBaseId ()"
|
|
|
|
char* ConverterState::ObjectType::PyBaseId ( PyTypeObject* pyType )
|
|
{
|
|
if ( _idBase[0] == '\0' ) return _id;
|
|
if ( ! strcmp(_id,_inheritStop) ) return _id;
|
|
return ( __cs.getObject(_idBase)->PyBase(pyType)->_id );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Destructor : "::ConverterState::~ConverterState ()"
|
|
|
|
ConverterState::~ConverterState () {
|
|
for ( unsigned i=0 ; i < _types.size() ; i++ )
|
|
delete _types [ i ];
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::addType ()"
|
|
|
|
void ConverterState::addType ( const char* id
|
|
, PyTypeObject* pyType
|
|
, const char* name
|
|
, bool isPythonType
|
|
, const char* idBase ) {
|
|
for ( unsigned i=0 ; i < _types.size() ; i++ ) {
|
|
if ( ! strcmp ( _types[i]->_id, id ) ) {
|
|
cdebug_log(20,0) << objectTypeRedefinition << endl;
|
|
return;
|
|
}
|
|
}
|
|
|
|
assert ( strlen ( id ) < 11 );
|
|
|
|
ObjectType* otype = new ObjectType;
|
|
strcpy ( otype->_id, id );
|
|
otype->_pyType = pyType;
|
|
otype->_name = name;
|
|
otype->_isPythonType = isPythonType;
|
|
strcpy ( otype->_idBase, idBase );
|
|
otype->_index = _types.size();
|
|
|
|
_types.push_back ( otype );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::getObjectType ()"
|
|
|
|
string ConverterState::getObjectType ( string objectsTypes, unsigned n ) {
|
|
string temp;
|
|
size_t end, head, tail, start;
|
|
|
|
unsigned element = 0;
|
|
|
|
end = objectsTypes.size();
|
|
if ( end > 0 ) {
|
|
for ( head=0 ; head <= end ; head=tail ) {
|
|
tail = objectsTypes.find ( ':' , head+1 );
|
|
start = head+1;
|
|
|
|
temp = objectsTypes.substr ( start, tail-start );
|
|
|
|
if ( n == element )
|
|
return temp;
|
|
|
|
element++;
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::getObjectId ()"
|
|
|
|
const char* ConverterState::getObjectId ( PyObject* object ) const {
|
|
for ( unsigned i=0 ; i < _types.size() ; i++ ) {
|
|
if ( ( not strcmp( _types[i]->_id, "function" ) ) and ( PyCallable_Check(object) ) )
|
|
return _types[i]->_id;
|
|
|
|
if ( (not strcmp( _types[i]->_id, "none")) and (object == Py_None) )
|
|
return _types[i]->_id;
|
|
|
|
if (object->ob_type == _types[i]->_pyType) return _types[i]->_id;
|
|
if (&PyLong_Type == _types[i]->_pyType) {
|
|
cerr << "PyLong_Type, now check for PyInt_Type" << endl;
|
|
if (object->ob_type == &PyInt_Type) return _types[i]->_id;
|
|
}
|
|
}
|
|
|
|
return ( "unknown" ); // return 'X'
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::getObject ()"
|
|
|
|
ConverterState::ObjectType* ConverterState::getObject ( char* id ) {
|
|
for ( unsigned i=0 ; i < _types.size() ; i++ ) {
|
|
if ( ! strcmp ( id, _types[i]->_id ) ) return ( _types[i] );
|
|
}
|
|
|
|
return ( NULL );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::getObjectName ()"
|
|
|
|
const char *ConverterState::getObjectName ( string id ) const {
|
|
for ( unsigned i=0 ; i < _types.size() ; i++ ) {
|
|
if ( ! strcmp ( id.c_str(), _types[i]->_id ) ) return ( _types[i]->_name );
|
|
}
|
|
return ( "<Unknown>" );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Method : "::ConverterState::init ()"
|
|
|
|
void ConverterState::init ( const char* function, const char* inheritStop ) {
|
|
_objectIds = "";
|
|
setFunction ( function );
|
|
ObjectType::_inheritStop = inheritStop;
|
|
};
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Function : "Converter ()"
|
|
|
|
int Converter ( PyObject* object, void** pArg )
|
|
{
|
|
ostringstream message;
|
|
string unboundObject = "";
|
|
ConverterState::ObjectType* baseType;
|
|
|
|
for ( unsigned i=0 ; i < __cs.getTypes().size() ; i++ ) {
|
|
PyTypeObject* obType = object->ob_type;
|
|
if (obType == &PyInt_Type) obType = &PyLong_Type;
|
|
|
|
baseType = __cs.getTypes()[i]->PyBase( obType );
|
|
if (PyCallable_Check(object) or baseType) {
|
|
*pArg = object;
|
|
i = baseType->_index;
|
|
__cs.addId( baseType->_id );
|
|
|
|
if (not __cs.getTypes()[i]->_isPythonType) {
|
|
void** member = ( (void**)( (unsigned long)object + __objectOffset ) );
|
|
|
|
if (*member == NULL) {
|
|
unboundObject = __cs.getTypes()[i]->_name;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (unboundObject.size()) {
|
|
message << "Attempt to call " << __cs.getFunction()
|
|
<< "() with an unbound " << unboundObject << " argument";
|
|
|
|
PyErr_SetString( ProxyError, message.str().c_str() );
|
|
return 0;
|
|
}
|
|
|
|
message << "Argument " << __cs.getSize() + 1
|
|
<< " of call to " << __cs.getFunction()
|
|
<< "() is of unmanaged type " << object->ob_type->tp_name;
|
|
|
|
PyErr_SetString( ProxyError, message.str().c_str() );
|
|
return 0;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Function : "ParseOneArg ()"
|
|
|
|
bool ParseOneArg ( const char* function, PyObject* args, string format, PyObject** arg ) {
|
|
ostringstream message;
|
|
|
|
__cs.init ( function );
|
|
if (not PyArg_ParseTuple(args,"O&",Converter,arg)) {
|
|
ostringstream m;
|
|
m << function << ": Take exactly one argument.";
|
|
PyErr_SetString(ConstructorError, m.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
string firstArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 0 );
|
|
string firstArgTypeExp = ConverterState::getObjectType ( format , 0 );
|
|
|
|
if ( firstArgType != firstArgTypeExp ) {
|
|
ostringstream m;
|
|
m << function << ": Argument type mismatch, should be:<" << firstArgTypeExp
|
|
<< "> not <" << firstArgType << ">";
|
|
PyErr_SetString(ConstructorError, m.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Function : "ParseTwoArg ()"
|
|
|
|
bool ParseTwoArg ( const char* function, PyObject* args, string format, PyObject** arg0, PyObject** arg1 ) {
|
|
ostringstream message;
|
|
__cs.init ( function );
|
|
if (not PyArg_ParseTuple(args,"O&O&",Converter,arg0,Converter,arg1)) {
|
|
ostringstream m;
|
|
m << function << ": Take exactly two argument.";
|
|
PyErr_SetString(ConstructorError, m.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
string firstArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 0 );
|
|
string firstArgTypeExp = ConverterState::getObjectType ( format , 0 );
|
|
|
|
if ( firstArgType != firstArgTypeExp ) {
|
|
ostringstream m;
|
|
m << function << ": First argument type mismatch, should be:<" << firstArgTypeExp
|
|
<< "> not <" << firstArgType << ">";
|
|
PyErr_SetString(ConstructorError, m.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
string secondArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 1 );
|
|
string secondArgTypeExp = ConverterState::getObjectType ( format , 1 );
|
|
|
|
if ( secondArgType != secondArgTypeExp ) {
|
|
ostringstream m;
|
|
m << function << ": Second argument type mismatch, should be:<" << secondArgTypeExp
|
|
<< "> not <" << secondArgType << ">";
|
|
PyErr_SetString(ConstructorError, m.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Function : "ParseThreeArg ()"
|
|
|
|
bool ParseThreeArg ( const char* function, PyObject* args, string format, PyObject** arg0, PyObject** arg1, PyObject** arg2 ) {
|
|
ostringstream message;
|
|
__cs.init ( function );
|
|
if ( ! PyArg_ParseTuple(args,"O&O&O&",Converter,arg0,Converter,arg1,Converter,arg2) ) return ( false );
|
|
|
|
string firstArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 0 );
|
|
string firstArgTypeExp = ConverterState::getObjectType ( format , 0 );
|
|
if ( firstArgType != firstArgTypeExp ) {
|
|
return ( false );
|
|
}
|
|
string secondArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 1 );
|
|
string secondArgTypeExp = ConverterState::getObjectType ( format , 1 );
|
|
if ( secondArgType != secondArgTypeExp ) {
|
|
PyErr_SetString ( ProxyError, message.str().c_str() );
|
|
return ( false );
|
|
}
|
|
string thirdArgType = ConverterState::getObjectType ( __cs.getObjectIds(), 2 );
|
|
string thirdArgTypeExp = ConverterState::getObjectType ( format , 2 );
|
|
if ( thirdArgType != thirdArgTypeExp ) {
|
|
message << "Third argument of call to " << __cs.getFunction()
|
|
<< "() is of unexpected type " << (*arg2)->ob_type->tp_name
|
|
<< ", must be of type " << __cs.getObjectName( thirdArgTypeExp );
|
|
PyErr_SetString ( ProxyError, message.str().c_str() );
|
|
return ( false );
|
|
}
|
|
|
|
return ( true );
|
|
}
|
|
|
|
|
|
// +-----------------------------------------------------------------+
|
|
// | "PyHurricane" C Global Variables |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
extern "C" {
|
|
|
|
|
|
PyObject* ConstructorError = NULL;
|
|
PyObject* ProxyError = NULL;
|
|
PyObject* HurricaneError = NULL;
|
|
PyObject* CoriolisError = NULL;
|
|
PyObject* HurricaneWarning = NULL;
|
|
|
|
|
|
}
|
|
|
|
# else // End of PyHurricane Shared Library Code Part.
|
|
|
|
// +=================================================================+
|
|
// | "PyHurricane" Python Module Code Part |
|
|
// +=================================================================+
|
|
|
|
|
|
extern "C" {
|
|
|
|
// +-------------------------------------------------------------+
|
|
// | "PyHurricane" Module Methods |
|
|
// +-------------------------------------------------------------+
|
|
|
|
static PyObject* PyCommons_trace ( PyObject* self, PyObject* args )
|
|
{
|
|
HTRY
|
|
PyObject* state = NULL;
|
|
if (PyArg_ParseTuple(args , "O:Hurricane.trace()", &state)) {
|
|
if (PyObject_IsTrue(state)) { } /*trace_on ();*/
|
|
else { } /*trace_off();*/
|
|
} else {
|
|
PyErr_SetString ( ConstructorError, "Bad parameters given to BasicLayer.create()." );
|
|
return NULL;
|
|
}
|
|
HCATCH
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
static PyMethodDef PyHurricane_Methods[] =
|
|
{ { "trace" , PyCommons_trace , METH_VARARGS, "Switch on/off the trace mode (for debugging)." }
|
|
, { "DbU_db" , PyDbU_fromDb , METH_VARARGS, "Converts an integer to DbU::Unit (no scale factor)." }
|
|
, { "DbU_grid" , PyDbU_fromGrid , METH_VARARGS, "Converts a founder grid to DbU::Unit." }
|
|
, { "DbU_lambda" , PyDbU_fromLambda , METH_VARARGS, "Converts a symbolic (lambda) to DbU::Unit." }
|
|
, { "DbU_getDb" , PyDbU_toDb , METH_VARARGS, "Converts a DbU::Unit to an integer value (no scale factor)." }
|
|
, { "DbU_getGrid" , PyDbU_toGrid , METH_VARARGS, "Converts a DbU::Unit to a to grid founder." }
|
|
, { "DbU_getLambda" , PyDbU_toLambda , METH_VARARGS, "Converts a DbU::Unit to a symbolic value (to lambda)." }
|
|
, { "DbU_getPhysical" , PyDbU_toPhysical , METH_VARARGS, "Converts a DbU::Unit to a physical value." }
|
|
, { "DbU_getOnPhysicalGrid", PyDbU_getOnPhysicalGrid, METH_VARARGS, "Adjusts a DbU::Unit to physical grid." }
|
|
, {NULL, NULL, 0, NULL} /* sentinel */
|
|
};
|
|
|
|
|
|
// ---------------------------------------------------------------
|
|
// Module Initialization : "initHurricane ()"
|
|
|
|
DL_EXPORT(void) initHurricane () {
|
|
//trace_on();
|
|
cdebug_log(20,0) << "initHurricane()" << endl;
|
|
|
|
PyDebugSession_LinkPyType ();
|
|
PyUpdateSession_LinkPyType ();
|
|
PyDbU_LinkPyType ();
|
|
PyPoint_LinkPyType ();
|
|
PyPointCollection_LinkPyType ();
|
|
PyInterval_LinkPyType ();
|
|
PyBox_LinkPyType ();
|
|
PyTransformation_LinkPyType ();
|
|
PyOrientation_LinkPyType ();
|
|
PyDataBase_LinkPyType ();
|
|
PyTechnology_LinkPyType ();
|
|
PyLibrary_LinkPyType ();
|
|
PyEntity_LinkPyType ();
|
|
PyLayer_LinkPyType ();
|
|
PyLayerMask_LinkPyType ();
|
|
PyBasicLayer_LinkPyType ();
|
|
PyRegularLayer_LinkPyType ();
|
|
PyDiffusionLayer_LinkPyType ();
|
|
PyTransistorLayer_LinkPyType ();
|
|
PyContactLayer_LinkPyType ();
|
|
PyViaLayer_LinkPyType ();
|
|
PyLayerCollection_LinkPyType ();
|
|
PyBasicLayerCollection_LinkPyType ();
|
|
PyRegularLayerCollection_LinkPyType ();
|
|
PyViaLayerCollection_LinkPyType ();
|
|
PyMaterial_LinkPyType ();
|
|
PyPath_LinkPyType ();
|
|
PyOccurrence_LinkPyType ();
|
|
PyInstanceCollection_LinkPyType ();
|
|
PyPlugCollection_LinkPyType ();
|
|
PyNetCollection_LinkPyType ();
|
|
PyNetExternalComponents_LinkPyType ();
|
|
PyNetRoutingState_LinkPyType ();
|
|
PyNetRoutingExtension_LinkPyType ();
|
|
PyCellCollection_LinkPyType ();
|
|
PyPinPlacementStatus_LinkPyType ();
|
|
PyPinDirection_LinkPyType ();
|
|
PyPinCollection_LinkPyType ();
|
|
PyRoutingPadCollection_LinkPyType ();
|
|
PySegmentCollection_LinkPyType ();
|
|
PyOccurrenceCollection_LinkPyType ();
|
|
PyComponentCollection_LinkPyType ();
|
|
PyReferenceCollection_LinkPyType ();
|
|
PyCell_LinkPyType ();
|
|
PyInstance_LinkPyType ();
|
|
PyPlacementStatus_LinkPyType ();
|
|
PyReference_LinkPyType ();
|
|
PyNet_LinkPyType ();
|
|
PyNetType_LinkPyType ();
|
|
PyNetDirection_LinkPyType ();
|
|
PyHyperNet_LinkPyType ();
|
|
PyHook_LinkPyType ();
|
|
PyHookCollection_LinkPyType ();
|
|
PyComponent_LinkPyType ();
|
|
PySegment_LinkPyType ();
|
|
PyPad_LinkPyType ();
|
|
PyDiagonal_LinkPyType ();
|
|
PyRoutingPad_LinkPyType ();
|
|
PyVertical_LinkPyType ();
|
|
PyHorizontal_LinkPyType ();
|
|
PyContact_LinkPyType ();
|
|
PyPin_LinkPyType ();
|
|
PyRectilinear_LinkPyType ();
|
|
PyPlug_LinkPyType ();
|
|
PyPolygon_LinkPyType ();
|
|
PyBreakpoint_LinkPyType ();
|
|
PyQuery_LinkPyType ();
|
|
PyQueryMask_LinkPyType ();
|
|
PyDeviceDescriptor_LinkPyType();
|
|
PyRule_LinkPyType();
|
|
PyUnitRule_LinkPyType();
|
|
PyPhysicalRule_LinkPyType();
|
|
PyTwoLayersPhysicalRule_LinkPyType();
|
|
|
|
PYTYPE_READY( DebugSession )
|
|
PYTYPE_READY( UpdateSession )
|
|
PYTYPE_READY( DbU )
|
|
PYTYPE_READY( Point )
|
|
PYTYPE_READY( PointCollection )
|
|
PYTYPE_READY( Interval )
|
|
PYTYPE_READY( Box )
|
|
PYTYPE_READY( Transformation )
|
|
PYTYPE_READY( Orientation )
|
|
PYTYPE_READY( DataBase )
|
|
PYTYPE_READY( Technology )
|
|
PYTYPE_READY( Library )
|
|
PYTYPE_READY( Entity )
|
|
PYTYPE_READY( Hook )
|
|
PYTYPE_READY( HookCollection )
|
|
PYTYPE_READY( Material )
|
|
PYTYPE_READY( Layer )
|
|
PYTYPE_READY( LayerMask )
|
|
PYTYPE_READY( BasicLayerCollection )
|
|
PYTYPE_READY( BasicLayerCollectionLocator )
|
|
PYTYPE_READY( LayerCollection )
|
|
PYTYPE_READY( LayerCollectionLocator )
|
|
PYTYPE_READY( RegularLayerCollection )
|
|
PYTYPE_READY( RegularLayerCollectionLocator )
|
|
PYTYPE_READY( ViaLayerCollection )
|
|
PYTYPE_READY( ViaLayerCollectionLocator )
|
|
PYTYPE_READY( Path )
|
|
PYTYPE_READY( Occurrence )
|
|
PYTYPE_READY( PlacementStatus )
|
|
PYTYPE_READY( InstanceCollection )
|
|
PYTYPE_READY( InstanceCollectionLocator )
|
|
PYTYPE_READY( PlugCollection )
|
|
PYTYPE_READY( PlugCollectionLocator )
|
|
PYTYPE_READY( NetType )
|
|
PYTYPE_READY( NetDirection )
|
|
PYTYPE_READY( NetCollection )
|
|
PYTYPE_READY( NetCollectionLocator )
|
|
PYTYPE_READY( NetRoutingState )
|
|
PYTYPE_READY( NetRoutingExtension )
|
|
PYTYPE_READY( CellCollection )
|
|
PYTYPE_READY( CellCollectionLocator )
|
|
PYTYPE_READY( PinPlacementStatus )
|
|
PYTYPE_READY( PinDirection )
|
|
PYTYPE_READY( PinCollection )
|
|
PYTYPE_READY( PinCollectionLocator )
|
|
PYTYPE_READY( RoutingPadCollection )
|
|
PYTYPE_READY( RoutingPadCollectionLocator )
|
|
PYTYPE_READY( SegmentCollection )
|
|
PYTYPE_READY( SegmentCollectionLocator )
|
|
PYTYPE_READY( ComponentCollection )
|
|
PYTYPE_READY( ComponentCollectionLocator )
|
|
PYTYPE_READY( OccurrenceCollection )
|
|
PYTYPE_READY( OccurrenceCollectionLocator )
|
|
PYTYPE_READY( ReferenceCollection )
|
|
PYTYPE_READY( ReferenceCollectionLocator )
|
|
PYTYPE_READY( HyperNet )
|
|
PYTYPE_READY( NetExternalComponents )
|
|
PYTYPE_READY( Breakpoint )
|
|
PYTYPE_READY( Query )
|
|
PYTYPE_READY( QueryMask )
|
|
PYTYPE_READY( DeviceDescriptor )
|
|
PYTYPE_READY( Rule )
|
|
|
|
PYTYPE_READY_SUB( BasicLayer , Layer )
|
|
PYTYPE_READY_SUB( RegularLayer , Layer )
|
|
PYTYPE_READY_SUB( ContactLayer , Layer )
|
|
PYTYPE_READY_SUB( DiffusionLayer , Layer )
|
|
PYTYPE_READY_SUB( TransistorLayer, Layer )
|
|
PYTYPE_READY_SUB( ViaLayer , Layer )
|
|
PYTYPE_READY_SUB( Cell , Entity )
|
|
PYTYPE_READY_SUB( Instance , Entity )
|
|
PYTYPE_READY_SUB( Reference , Entity )
|
|
PYTYPE_READY_SUB( Net , Entity )
|
|
PYTYPE_READY_SUB( Component , Entity )
|
|
PYTYPE_READY_SUB( RoutingPad , Component)
|
|
PYTYPE_READY_SUB( Segment , Component)
|
|
PYTYPE_READY_SUB( Horizontal , Segment )
|
|
PYTYPE_READY_SUB( Vertical , Segment )
|
|
|
|
PYTYPE_READY_SUB( Contact , Component)
|
|
PYTYPE_READY_SUB( Pin , Contact )
|
|
PYTYPE_READY_SUB( Plug , Component)
|
|
PYTYPE_READY_SUB( Pad , Component)
|
|
PYTYPE_READY_SUB( Diagonal , Component)
|
|
PYTYPE_READY_SUB( Rectilinear , Component)
|
|
PYTYPE_READY_SUB( Polygon , Component)
|
|
|
|
PYTYPE_READY_SUB( UnitRule , Rule )
|
|
PYTYPE_READY_SUB( PhysicalRule , Rule )
|
|
PYTYPE_READY_SUB( TwoLayersPhysicalRule, PhysicalRule )
|
|
|
|
// Identifier string can take up to 10 characters !
|
|
__cs.addType( "intv" , &PyTypeInterval , "<Interval>" , false );
|
|
__cs.addType( "box" , &PyTypeBox , "<Box>" , false );
|
|
__cs.addType( "ent" , &PyTypeEntity , "<Entity>" , false );
|
|
__cs.addType( "cell" , &PyTypeCell , "<Cell>" , false, "ent" );
|
|
__cs.addType( "cellCol" , &PyTypeCellCollection , "<CellCollection>" , false );
|
|
__cs.addType( "hook" , &PyTypeHook , "<Hook>" , false );
|
|
__cs.addType( "hookColl" , &PyTypeHookCollection , "<HookCollection>" , false );
|
|
__cs.addType( "comp" , &PyTypeComponent , "<Component>" , false, "ent" );
|
|
__cs.addType( "compCol" , &PyTypeComponentCollection , "<ComponentCollection>" , false );
|
|
__cs.addType( "contact" , &PyTypeContact , "<Contact>" , false, "comp" );
|
|
// Do not change the "none" string. It's hardwired to the None object.
|
|
__cs.addType( "none" , Py_None->ob_type , "<None>" , true );
|
|
__cs.addType( "float" , &PyFloat_Type , "<Float>" , true );
|
|
__cs.addType( "int" , &PyLong_Type , "<Int>" , true );
|
|
__cs.addType( "bool" , &PyBool_Type , "<Bool>" , true );
|
|
__cs.addType( "string" , &PyString_Type , "<String>" , true );
|
|
__cs.addType( "list" , &PyList_Type , "<List>" , true );
|
|
// Do not change the "function" string. It's hardwired to callable (function) objects.
|
|
__cs.addType( "function" , NULL , "<Function>" , true );
|
|
__cs.addType( "horiz" , &PyTypeHorizontal , "<Horizontal>" , false, "segment" );
|
|
__cs.addType( "inst" , &PyTypeInstance , "<Instance>" , false, "ent" );
|
|
__cs.addType( "instCol" , &PyTypeInstanceCollection , "<InstanceCollection>" , false );
|
|
__cs.addType( "mat" , &PyTypeMaterial , "<Material>" , false );
|
|
__cs.addType( "layer" , &PyTypeLayer , "<Layer>" , false );
|
|
__cs.addType( "basicLayer" , &PyTypeBasicLayer , "<BasicLayer>" , false, "layer" );
|
|
__cs.addType( "regLayer" , &PyTypeRegularLayer , "<RegularLayer>" , false, "layer" );
|
|
__cs.addType( "contLayer" , &PyTypeContactLayer , "<ContactLayer>" , false, "layer" );
|
|
__cs.addType( "diffLayer" , &PyTypeDiffusionLayer , "<DiffusionLayer>" , false, "layer" );
|
|
__cs.addType( "tranLayer" , &PyTypeTransistorLayer , "<TransistorLayer>" , false, "layer" );
|
|
__cs.addType( "viaLayer" , &PyTypeViaLayer , "<ViaLayer>" , false, "layer" );
|
|
__cs.addType( "layerColl" , &PyTypeLayerCollection , "<LayerCollection>" , false );
|
|
__cs.addType( "blayerColl" , &PyTypeBasicLayerCollection , "<BasicLayerCollection>" , false );
|
|
__cs.addType( "rlayerColl" , &PyTypeRegularLayerCollection, "<RegularLayerCollection>", false );
|
|
__cs.addType( "vlayerColl" , &PyTypeViaLayerCollection , "<ViaLayerCollection>" , false );
|
|
__cs.addType( "lmask" , &PyTypeLayerMask , "<Layer::Mask>" , false );
|
|
__cs.addType( "library" , &PyTypeLibrary , "<Library>" , false );
|
|
__cs.addType( "ref" , &PyTypeReference , "<Reference>" , false, "ent" );
|
|
__cs.addType( "refCol" , &PyTypeReferenceCollection , "<ReferenceCollection>" , false );
|
|
__cs.addType( "net" , &PyTypeNet , "<Net>" , false, "ent" );
|
|
__cs.addType( "netCol" , &PyTypeNetCollection , "<NetCollection>" , false );
|
|
__cs.addType( "hyperNet" , &PyTypeHyperNet , "<HyperNet>" , false );
|
|
__cs.addType( "pin" , &PyTypePin , "<Pin>" , false, "contact" );
|
|
__cs.addType( "pinCol" , &PyTypePinCollection , "<PinCollection>" , false );
|
|
__cs.addType( "rpCol" , &PyTypeRoutingPadCollection , "<RoutingPadCollection>" , false );
|
|
__cs.addType( "plug" , &PyTypePlug , "<Plug>" , false, "comp" );
|
|
__cs.addType( "plugCol" , &PyTypePlugCollection , "<PlugCollection>" , false );
|
|
__cs.addType( "point" , &PyTypePoint , "<Point>" , false );
|
|
__cs.addType( "points" , &PyTypePointCollection , "<Points>" , false );
|
|
__cs.addType( "rp" , &PyTypeRoutingPad , "<RoutingPad>" , false, "comp" );
|
|
__cs.addType( "segment" , &PyTypeSegment , "<Segment>" , false, "comp" );
|
|
__cs.addType( "pad " , &PyTypePad , "<Pad>" , false, "comp" );
|
|
__cs.addType( "diagonal" , &PyTypeDiagonal , "<Diagonal>" , false, "comp" );
|
|
__cs.addType( "rectilin" , &PyTypeRectilinear , "<Rectilinear>" , false, "comp" );
|
|
__cs.addType( "polygon" , &PyTypePolygon , "<Polygon>" , false, "comp" );
|
|
__cs.addType( "segmentCol" , &PyTypeSegmentCollection , "<SegmentCollection>" , false );
|
|
__cs.addType( "db" , &PyTypeDataBase , "<DataBase>" , false );
|
|
__cs.addType( "techno" , &PyTypeTechnology , "<Technology>" , false );
|
|
__cs.addType( "transfo" , &PyTypeTransformation , "<Transformation>" , false );
|
|
__cs.addType( "orient" , &PyTypeOrientation , "<Orientation>" , false );
|
|
__cs.addType( "vert" , &PyTypeVertical , "<Vertical>" , false, "segment" );
|
|
__cs.addType( "path" , &PyTypePath , "<Path>" , false );
|
|
__cs.addType( "occur" , &PyTypeOccurrence , "<Occurrence>" , false );
|
|
__cs.addType( "occurCol" , &PyTypeOccurrenceCollection , "<OccurrenceCollection>" , false );
|
|
__cs.addType( "query" , &PyTypeQuery , "<Query>" , false );
|
|
__cs.addType( "qmask" , &PyTypeQueryMask , "<Query::Mask>" , false );
|
|
__cs.addType( "devdesc" , &PyTypeDeviceDescriptor , "<DeviceDescriptor>" , false );
|
|
__cs.addType( "rule" , &PyTypeRule , "<Rule>" , false );
|
|
__cs.addType( "urule" , &PyTypeUnitRule , "<UnitRule>" , false, "rule" );
|
|
__cs.addType( "prule" , &PyTypePhysicalRule , "<PhysicalRule>" , false, "rule" );
|
|
__cs.addType( "2prule" , &PyTypeTwoLayersPhysicalRule , "<TwoLayersPhysicalRule>" , false, "prule" );
|
|
|
|
|
|
PyObject* module = Py_InitModule ( "Hurricane", PyHurricane_Methods );
|
|
if ( module == NULL ) {
|
|
cerr << "[ERROR]\n"
|
|
<< " Failed to initialize Hurricane module." << endl;
|
|
return;
|
|
}
|
|
|
|
Py_INCREF ( &PyTypeDbU );
|
|
PyModule_AddObject ( module, "DbU" , (PyObject*)&PyTypeDbU );
|
|
Py_INCREF ( &PyTypePoint );
|
|
PyModule_AddObject ( module, "Point" , (PyObject*)&PyTypePoint );
|
|
Py_INCREF ( &PyTypeInterval );
|
|
PyModule_AddObject ( module, "Interval" , (PyObject*)&PyTypeInterval );
|
|
Py_INCREF ( &PyTypeBox );
|
|
PyModule_AddObject ( module, "Box" , (PyObject*)&PyTypeBox );
|
|
Py_INCREF ( &PyTypeTransformation );
|
|
PyModule_AddObject ( module, "Transformation" , (PyObject*)&PyTypeTransformation );
|
|
Py_INCREF ( &PyTypePath );
|
|
PyModule_AddObject ( module, "Path" , (PyObject*)&PyTypePath );
|
|
Py_INCREF ( &PyTypeOccurrence );
|
|
PyModule_AddObject ( module, "Occurrence" , (PyObject*)&PyTypeOccurrence );
|
|
Py_INCREF ( &PyTypeDataBase );
|
|
PyModule_AddObject ( module, "DataBase" , (PyObject*)&PyTypeDataBase );
|
|
Py_INCREF ( &PyTypeLibrary );
|
|
PyModule_AddObject ( module, "Library" , (PyObject*)&PyTypeLibrary );
|
|
Py_INCREF ( &PyTypeNet );
|
|
PyModule_AddObject ( module, "Net" , (PyObject*)&PyTypeNet );
|
|
Py_INCREF ( &PyTypeHyperNet );
|
|
PyModule_AddObject ( module, "HyperNet" , (PyObject*)&PyTypeHyperNet );
|
|
Py_INCREF ( &PyTypeInstance );
|
|
PyModule_AddObject ( module, "Cell" , (PyObject*)&PyTypeCell );
|
|
Py_INCREF ( &PyTypeInstance );
|
|
PyModule_AddObject ( module, "Instance" , (PyObject*)&PyTypeInstance );
|
|
Py_INCREF ( &PyTypeTechnology );
|
|
PyModule_AddObject ( module, "Technology" , (PyObject*)&PyTypeTechnology );
|
|
Py_INCREF ( &PyTypeLayer );
|
|
PyModule_AddObject ( module, "Layer" , (PyObject*)&PyTypeLayer );
|
|
Py_INCREF ( &PyTypeBasicLayer );
|
|
PyModule_AddObject ( module, "BasicLayer" , (PyObject*)&PyTypeBasicLayer );
|
|
Py_INCREF ( &PyTypeRegularLayer );
|
|
PyModule_AddObject ( module, "RegularLayer" , (PyObject*)&PyTypeRegularLayer );
|
|
Py_INCREF ( &PyTypeContactLayer );
|
|
PyModule_AddObject ( module, "ContactLayer" , (PyObject*)&PyTypeContactLayer );
|
|
Py_INCREF ( &PyTypeDiffusionLayer );
|
|
PyModule_AddObject ( module, "DiffusionLayer" , (PyObject*)&PyTypeDiffusionLayer );
|
|
Py_INCREF ( &PyTypeTransistorLayer );
|
|
PyModule_AddObject ( module, "TransistorLayer" , (PyObject*)&PyTypeTransistorLayer );
|
|
Py_INCREF ( &PyTypeViaLayer );
|
|
PyModule_AddObject ( module, "ViaLayer" , (PyObject*)&PyTypeViaLayer );
|
|
Py_INCREF ( &PyTypeNetExternalComponents );
|
|
PyModule_AddObject ( module, "NetExternalComponents", (PyObject*)&PyTypeNetExternalComponents );
|
|
Py_INCREF ( &PyTypeNetRoutingState );
|
|
PyModule_AddObject ( module, "NetRoutingState" , (PyObject*)&PyTypeNetRoutingState );
|
|
Py_INCREF ( &PyTypeNetRoutingExtension );
|
|
PyModule_AddObject ( module, "NetRoutingExtension" , (PyObject*)&PyTypeNetRoutingExtension );
|
|
Py_INCREF ( &PyTypeDebugSession );
|
|
PyModule_AddObject ( module, "DebugSession" , (PyObject*)&PyTypeDebugSession );
|
|
Py_INCREF ( &PyTypeUpdateSession );
|
|
PyModule_AddObject ( module, "UpdateSession" , (PyObject*)&PyTypeUpdateSession );
|
|
Py_INCREF ( &PyTypeBreakpoint );
|
|
PyModule_AddObject ( module, "Breakpoint" , (PyObject*)&PyTypeBreakpoint );
|
|
Py_INCREF ( &PyTypeQuery );
|
|
PyModule_AddObject ( module, "Query" , (PyObject*)&PyTypeQuery );
|
|
Py_INCREF ( &PyTypeReference );
|
|
PyModule_AddObject ( module, "Reference" , (PyObject*)&PyTypeReference );
|
|
Py_INCREF ( &PyTypeHook );
|
|
PyModule_AddObject ( module, "Hook" , (PyObject*)&PyTypeHook );
|
|
Py_INCREF ( &PyTypeHookCollection );
|
|
PyModule_AddObject ( module, "HookCollection" , (PyObject*)&PyTypeHookCollection );
|
|
Py_INCREF ( &PyTypePlug );
|
|
PyModule_AddObject ( module, "Plug" , (PyObject*)&PyTypePlug );
|
|
Py_INCREF ( &PyTypeRoutingPad );
|
|
PyModule_AddObject ( module, "RoutingPad" , (PyObject*)&PyTypeRoutingPad );
|
|
Py_INCREF ( &PyTypeSegment );
|
|
PyModule_AddObject ( module, "Segment" , (PyObject*)&PyTypeSegment );
|
|
Py_INCREF ( &PyTypeVertical );
|
|
PyModule_AddObject ( module, "Vertical" , (PyObject*)&PyTypeVertical );
|
|
Py_INCREF ( &PyTypeHorizontal );
|
|
PyModule_AddObject ( module, "Horizontal" , (PyObject*)&PyTypeHorizontal );
|
|
Py_INCREF ( &PyTypeContact );
|
|
PyModule_AddObject ( module, "Contact" , (PyObject*)&PyTypeContact );
|
|
Py_INCREF ( &PyTypePin );
|
|
PyModule_AddObject ( module, "Pin" , (PyObject*)&PyTypePin );
|
|
Py_INCREF ( &PyTypePad );
|
|
PyModule_AddObject ( module, "Pad" , (PyObject*)&PyTypePad );
|
|
Py_INCREF ( &PyTypeDiagonal );
|
|
PyModule_AddObject ( module, "Diagonal" , (PyObject*)&PyTypeDiagonal );
|
|
Py_INCREF ( &PyTypeRectilinear );
|
|
PyModule_AddObject ( module, "Rectilinear" , (PyObject*)&PyTypeRectilinear );
|
|
Py_INCREF ( &PyTypePolygon );
|
|
PyModule_AddObject ( module, "Polygon" , (PyObject*)&PyTypePolygon );
|
|
Py_INCREF( &PyTypeDeviceDescriptor );
|
|
PyModule_AddObject( module, "DeviceDescriptor" , (PyObject*)&PyTypeDeviceDescriptor );
|
|
|
|
|
|
PyObject* dictionnary = PyModule_GetDict ( module );
|
|
|
|
ConstructorError = PyErr_NewException ( (char*)"hurricane.ConstructorError", NULL, NULL );
|
|
ProxyError = PyErr_NewException ( (char*)"hurricane.ProxyError" , NULL, NULL );
|
|
HurricaneError = PyErr_NewException ( (char*)"hurricane.HurricaneError" , NULL, NULL );
|
|
HurricaneWarning = PyErr_NewException ( (char*)"hurricane.HurricaneWarning", PyExc_Warning, NULL );
|
|
|
|
PyDict_SetItemString ( dictionnary, "ConstructorError", ConstructorError );
|
|
PyDict_SetItemString ( dictionnary, "ProxyError" , ProxyError );
|
|
PyDict_SetItemString ( dictionnary, "HurricaneError" , HurricaneError );
|
|
|
|
DbULoadConstants( dictionnary );
|
|
|
|
PyDbU_postModuleInit();
|
|
PyTransformation_postModuleInit();
|
|
PyLayer_postModuleInit();
|
|
PyBasicLayer_postModuleInit();
|
|
PyPin_postModuleInit();
|
|
PyRoutingPad_postModuleInit();
|
|
PyNet_postModuleInit();
|
|
PyNetRoutingState_postModuleInit();
|
|
PyInstance_postModuleInit();
|
|
PyQuery_postModuleInit();
|
|
|
|
cdebug_log(20,0) << "Hurricane.so loaded " << (void*)&typeid(string) << endl;
|
|
}
|
|
|
|
|
|
} // extern "C".
|
|
|
|
#endif // End of Python Module Code Part.
|
|
|
|
} // Isobar namespace.
|