// -*- 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.