haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Eeschema Eagle Import: WIP trying to fix indirect memory leaks

This commit is contained in:
Russell Oliver 2017-08-07 00:20:29 +10:00 committed by Maciej Suminski
parent 1fdb13daa6
commit 956ef0fa61
3 changed files with 68 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
eeschema/sch_eagle_plugin.cpp
View File

@ -491,9 +491,9 @@ void SCH_EAGLE_PLUGIN::loadSchematic( wxXmlNode* aSchematicNode )
while( partNode )
{
std::unique_ptr<EPART> epart( new EPART( partNode ) );
const string& name = epart->name;
m_partlist[name] = epart.release();
std::unique_ptr<EPART> epart( new EPART(partNode) );
string name = epart->name;
m_partlist[name] = std::move(epart);
partNode = partNode->GetNext();
}
@ -509,8 +509,8 @@ void SCH_EAGLE_PLUGIN::loadSchematic( wxXmlNode* aSchematicNode )
while( libraryNode )
{
auto elib = loadLibrary( libraryNode );
m_eaglelibraries[elib->name] = elib;
EAGLE_LIBRARY elib = loadLibrary( libraryNode );
m_eaglelibraries[elib.name] = elib;
libraryNode = libraryNode->GetNext();
}
@ -1016,13 +1016,13 @@ void SCH_EAGLE_PLUGIN::loadInstance( wxXmlNode* aInstanceNode )
// Assign the the LIB_ID from deviceset and device names
EPART* epart = m_partlist[einstance.part];
EPART* epart = m_partlist[einstance.part].get();
std::string gatename = epart->deviceset + epart->device + einstance.gate;
std::string symbolname = epart->deviceset + epart->device;
// KiCad enumerates units starting from 1, Eagle starts with 0
int unit = m_eaglelibraries[epart->library]->gate_unit[gatename];
std::string package = m_eaglelibraries[epart->library]->package[symbolname];
int unit = m_eaglelibraries[epart->library].gate_unit[gatename];
std::string package = m_eaglelibraries[epart->library].package[symbolname];
// std::cout << "Instance> part: " << einstance.part << " Gate: " << einstance.gate << " " << symbolname << '\n';
@ -1147,15 +1147,15 @@ void SCH_EAGLE_PLUGIN::loadModuleinst( wxXmlNode* aModuleinstNode )
}
EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
EAGLE_LIBRARY SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
{
unique_ptr<EAGLE_LIBRARY> elib( new EAGLE_LIBRARY );
std::map<std::string, wxXmlNode*> gate;
EAGLE_LIBRARY elib;
// Read the library name
wxString libName = aLibraryNode->GetAttribute( "name" );
elib.get()->name = libName.ToStdString();
elib.name = libName.ToStdString();
////std::cout << "Importing Eagle Library "<< libName.ToStdString() << std::endl;
@ -1180,7 +1180,7 @@ EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
while( symbolNode )
{
wxString symbolName = symbolNode->GetAttribute( "name" );
elib->symbolnodes[symbolName.ToStdString()] = symbolNode;
elib.symbolnodes[symbolName.ToStdString()] = symbolNode;
symbolNode = symbolNode->GetNext();
}
@ -1208,7 +1208,7 @@ EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
// std::cout << "Creating Kicad Symbol: " << symbolName.ToStdString() << '\n';
if( edevice.package )
elib.get()->package[symbolName.ToStdString()] = edevice.package.Get();
elib.package[symbolName.ToStdString()] = edevice.package.Get();
// Create kicad symbol.
unique_ptr<LIB_PART> kpart( new LIB_PART( symbolName ) );
@ -1226,11 +1226,11 @@ EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
{
EGATE egate = EGATE( gateNode );
elib.get()->gate_unit[edeviceset.name + edevice.name + egate.name] = gateindex;
elib.gate_unit[edeviceset.name + edevice.name + egate.name] = gateindex;
ispower = loadSymbol( elib->symbolnodes[egate.symbol],
(LIB_PART*) kpart.get(), &edevice, gateindex, egate.name );
ispower = loadSymbol( elib.symbolnodes[egate.symbol],
kpart, &edevice, gateindex, egate.name );
gateindex++;
gateNode = gateNode->GetNext();
@ -1241,7 +1241,7 @@ EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
const string& name = kpart->GetName().ToStdString();
m_partlib->AddPart( kpart.get() );
elib->kicadsymbols[name] = kpart.release();
elib.kicadsymbols[name] = kpart.release();
deviceNode = deviceNode->GetNext();
} // devicenode
@ -1249,12 +1249,12 @@ EAGLE_LIBRARY* SCH_EAGLE_PLUGIN::loadLibrary( wxXmlNode* aLibraryNode )
devicesetNode = devicesetNode->GetNext();
} // devicesetNode
return elib.release();
return elib;
}
bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
LIB_PART* aPart,
std::unique_ptr< LIB_PART >& aPart,
EDEVICE* aDevice,
int gateNumber,
string gateName )
@ -1288,14 +1288,12 @@ bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
}
else if( nodeName == "circle" )
{
LIB_CIRCLE* circle = loadSymbolCircle( aPart, currentNode );
circle->SetUnit( gateNumber );
aPart->AddDrawItem( circle );
aPart->AddDrawItem( loadSymbolCircle( aPart, currentNode, gateNumber) );
}
else if( nodeName == "pin" )
{
EPIN ePin = EPIN( currentNode );
LIB_PIN* pin = loadPin( aPart, currentNode, &ePin );
std::unique_ptr<LIB_PIN> pin ( loadPin( aPart, currentNode, &ePin, gateNumber ) );
pincount++;
if(ePin.direction)
@ -1366,7 +1364,7 @@ bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
pinname.Replace("!", "~");
pin->SetName( pinname );
aPart->AddDrawItem( pin );
aPart->AddDrawItem( pin.release() );
break;
}
}
@ -1375,27 +1373,20 @@ bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
{
pin->SetPartNumber( gateNumber );
pin->SetUnit( gateNumber );
aPart->AddDrawItem( pin );
aPart->AddDrawItem( pin.release() );
}
}
else if( nodeName == "polygon" )
{
LIB_POLYLINE* libpoly = loadSymbolPolyLine( aPart, currentNode );
libpoly->SetUnit( gateNumber );
aPart->AddDrawItem(libpoly);
aPart->AddDrawItem( loadSymbolPolyLine( aPart, currentNode, gateNumber ) );
}
else if( nodeName == "rectangle" )
{
LIB_RECTANGLE* rectangle = loadSymbolRectangle( aPart, currentNode );
rectangle->SetUnit( gateNumber );
aPart->AddDrawItem( rectangle );
aPart->AddDrawItem( loadSymbolRectangle( aPart, currentNode, gateNumber ));
}
else if( nodeName == "text" )
{
LIB_TEXT* libtext = loadSymboltext( aPart, currentNode );
libtext->SetUnit( gateNumber );
std::unique_ptr<LIB_TEXT> libtext ( loadSymboltext( aPart, currentNode , gateNumber) );
if( libtext->GetText().Upper() ==">NAME" )
{
@ -1421,14 +1412,13 @@ bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
}
else
{
aPart->AddDrawItem( libtext );
aPart->AddDrawItem( libtext.release() );
}
}
else if( nodeName == "wire" )
{
LIB_ITEM* pline = loadSymbolWire( aPart, currentNode );
pline->SetUnit( gateNumber );
aPart->AddDrawItem( pline );
aPart->AddDrawItem( loadSymbolWire( aPart, currentNode, gateNumber ) );
}
currentNode = currentNode->GetNext();
@ -1443,33 +1433,34 @@ bool SCH_EAGLE_PLUGIN::loadSymbol( wxXmlNode* aSymbolNode,
}
LIB_CIRCLE* SCH_EAGLE_PLUGIN::loadSymbolCircle( LIB_PART* aPart, wxXmlNode* aCircleNode )
LIB_CIRCLE* SCH_EAGLE_PLUGIN::loadSymbolCircle( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aCircleNode , int gateNumber)
{
// Parse the circle properties
ECIRCLE c( aCircleNode );
unique_ptr<LIB_CIRCLE> circle( new LIB_CIRCLE( aPart ) );
unique_ptr<LIB_CIRCLE> circle( new LIB_CIRCLE( aPart.get() ) );
circle->SetPosition( wxPoint( c.x * EUNIT_TO_MIL, c.y * EUNIT_TO_MIL ) );
circle->SetRadius( c.radius * EUNIT_TO_MIL );
circle->SetWidth( c.width * EUNIT_TO_MIL );
circle->SetUnit( gateNumber );
return circle.release();
}
LIB_RECTANGLE* SCH_EAGLE_PLUGIN::loadSymbolRectangle( LIB_PART* aPart, wxXmlNode* aRectNode )
LIB_RECTANGLE* SCH_EAGLE_PLUGIN::loadSymbolRectangle( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aRectNode , int gateNumber )
{
ERECT rect( aRectNode );
unique_ptr<LIB_RECTANGLE> rectangle( new LIB_RECTANGLE( aPart ) );
unique_ptr<LIB_RECTANGLE> rectangle( new LIB_RECTANGLE( aPart.get() ) );
rectangle->SetPosition( wxPoint( rect.x1 * EUNIT_TO_MIL, rect.y1 * EUNIT_TO_MIL ) );
rectangle->SetEnd( wxPoint( rect.x2 * EUNIT_TO_MIL, rect.y2 * EUNIT_TO_MIL ) );
// TODO: Manage rotation
// Probaly using a transform.
rectangle->SetUnit( gateNumber );
// Eagle rectangles are filled by definition.
rectangle->SetFillMode(FILLED_SHAPE);
@ -1477,7 +1468,7 @@ LIB_RECTANGLE* SCH_EAGLE_PLUGIN::loadSymbolRectangle( LIB_PART* aPart, wxXmlNode
}
LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNode )
LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aWireNode, int gateNumber)
{
// TODO: Layer map
@ -1492,7 +1483,7 @@ LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNod
end.y = ewire.y2 * EUNIT_TO_MIL;
if( ewire.curve )
{
std::unique_ptr<LIB_ARC> arc( new LIB_ARC( aPart ) );
std::unique_ptr<LIB_ARC> arc( new LIB_ARC( aPart.get() ) );
wxRealPoint center = kicad_arc_center( begin, end, *ewire.curve*-1);
arc->SetPosition(center);
@ -1534,7 +1525,7 @@ LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNod
arc->SetEnd( end );
arc->SetRadius(radius);
arc->CalcRadiusAngles();
arc->SetWidth(0.001);
arc->SetWidth(1);
arc->SetFillMode(FILLED_SHAPE);
}
@ -1544,7 +1535,7 @@ LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNod
}
else
{
std::unique_ptr<LIB_POLYLINE> polyLine( new LIB_POLYLINE( aPart ) );
std::unique_ptr<LIB_POLYLINE> polyLine( new LIB_POLYLINE( aPart.get() ) );
polyLine->AddPoint( begin );
polyLine->AddPoint( end );
@ -1556,10 +1547,10 @@ LIB_ITEM* SCH_EAGLE_PLUGIN::loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNod
}
LIB_POLYLINE* SCH_EAGLE_PLUGIN::loadSymbolPolyLine( LIB_PART* aPart, wxXmlNode* aPolygonNode )
LIB_POLYLINE* SCH_EAGLE_PLUGIN::loadSymbolPolyLine( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aPolygonNode, int gateNumber )
{
// TODO: Layer map
std::unique_ptr<LIB_POLYLINE> polyLine( new LIB_POLYLINE( aPart ) );
std::unique_ptr<LIB_POLYLINE> polyLine( new LIB_POLYLINE( aPart.get() ) );
EPOLYGON epoly( aPolygonNode );
wxXmlNode* vertex = aPolygonNode->GetChildren();
@ -1578,19 +1569,20 @@ LIB_POLYLINE* SCH_EAGLE_PLUGIN::loadSymbolPolyLine( LIB_PART* aPart, wxXmlNode*
}
polyLine->SetFillMode( FILLED_SHAPE );
polyLine->SetUnit( gateNumber );
return polyLine.release();
}
LIB_PIN* SCH_EAGLE_PLUGIN::loadPin( LIB_PART* aPart, wxXmlNode* aPin, EPIN* epin )
LIB_PIN* SCH_EAGLE_PLUGIN::loadPin( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aPin, EPIN* epin , int gateNumber )
{
std::unique_ptr<LIB_PIN> pin( new LIB_PIN( aPart ) );
std::unique_ptr<LIB_PIN> pin( new LIB_PIN( aPart.get() ) );
epin = new EPIN( aPin );
pin->SetPosition( wxPoint( epin->x * EUNIT_TO_MIL, epin->y * EUNIT_TO_MIL ) );
pin->SetName( epin->name );
pin->SetUnit( gateNumber );
int roti = 0;
@ -1672,12 +1664,13 @@ LIB_PIN* SCH_EAGLE_PLUGIN::loadPin( LIB_PART* aPart, wxXmlNode* aPin, EPIN* epin
}
LIB_TEXT* SCH_EAGLE_PLUGIN::loadSymboltext( LIB_PART* aPart, wxXmlNode* aLibText )
LIB_TEXT* SCH_EAGLE_PLUGIN::loadSymboltext( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aLibText, int gateNumber )
{
std::unique_ptr<LIB_TEXT> libtext( new LIB_TEXT( aPart ) );
std::unique_ptr<LIB_TEXT> libtext( new LIB_TEXT( aPart.get() ) );
auto etext = ETEXT( aLibText );
ETEXT etext( aLibText );
libtext->SetUnit( gateNumber );
libtext->SetPosition( wxPoint( etext.x * EUNIT_TO_MIL, etext.y * EUNIT_TO_MIL ) );
libtext->SetText( aLibText->GetNodeContent() );
libtext->SetTextSize( wxSize( etext.size * EUNIT_TO_MIL*0.95,
@ -1701,6 +1694,7 @@ LIB_TEXT* SCH_EAGLE_PLUGIN::loadSymboltext( LIB_PART* aPart, wxXmlNode* aLibText
eagleToKicadAlignment((EDA_TEXT*)libtext.get(), align, degrees, mirror, spin, 0);
return libtext.release();
}

29
eeschema/sch_eagle_plugin.h
View File

@ -29,6 +29,8 @@
#include <lib_draw_item.h>
#include <dlist.h>
#include <boost/ptr_container/ptr_map.hpp>
class KIWAY;
class LINE_READER;
class SCH_SCREEN;
@ -67,14 +69,15 @@ class LIB_TEXT;
typedef struct EAGLE_LIBRARY
{
std::string name;
std::unordered_map<std::string, LIB_PART*> kicadsymbols;
std::unordered_map<std::string, wxXmlNode*> symbolnodes;
boost::ptr_map<std::string, LIB_PART*> kicadsymbols;
boost::ptr_map<std::string, wxXmlNode*> symbolnodes;
std::unordered_map<std::string, int> gate_unit;
std::unordered_map<std::string, std::string> package;
} EAGLE_LIBRARY;
typedef std::map<std::string, EPART*> EPART_LIST;
typedef boost::ptr_map< std::string, EPART > EPART_LIST;
class SCH_EAGLE_PLUGIN : public SCH_PLUGIN
{
@ -134,7 +137,7 @@ private:
void loadSheet( wxXmlNode* aSheetNode );
void loadInstance( wxXmlNode* aInstanceNode );
void loadModuleinst( wxXmlNode* aModuleinstNode );
EAGLE_LIBRARY* loadLibrary( wxXmlNode* aLibraryNode );
EAGLE_LIBRARY loadLibrary( wxXmlNode* aLibraryNode );
void countNets( wxXmlNode* aSchematicNode );
void addBusEntries();
@ -148,13 +151,13 @@ private:
SCH_JUNCTION* loadJunction( wxXmlNode* aJunction );
SCH_TEXT* loadplaintext( wxXmlNode* aSchText );
bool loadSymbol(wxXmlNode *aSymbolNode, LIB_PART* aPart, EDEVICE* aDevice, int gateNumber, string gateName);
LIB_CIRCLE* loadSymbolCircle( LIB_PART* aPart, wxXmlNode* aCircleNode );
LIB_RECTANGLE* loadSymbolRectangle( LIB_PART* aPart, wxXmlNode* aRectNode );
LIB_POLYLINE* loadSymbolPolyLine( LIB_PART* aPart, wxXmlNode* aPolygonNode );
LIB_ITEM* loadSymbolWire( LIB_PART* aPart, wxXmlNode* aWireNode );
LIB_PIN* loadPin( LIB_PART*, wxXmlNode*, EPIN* epin);
LIB_TEXT* loadSymboltext( LIB_PART* aPart, wxXmlNode* aLibText );
bool loadSymbol(wxXmlNode *aSymbolNode, std::unique_ptr< LIB_PART >& aPart, EDEVICE* aDevice, int gateNumber, string gateName);
LIB_CIRCLE* loadSymbolCircle( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aCircleNode, int gateNumber);
LIB_RECTANGLE* loadSymbolRectangle( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aRectNode, int gateNumber );
LIB_POLYLINE* loadSymbolPolyLine( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aPolygonNode, int gateNumber );
LIB_ITEM* loadSymbolWire( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aWireNode, int gateNumber);
LIB_PIN* loadPin( std::unique_ptr< LIB_PART >& aPart, wxXmlNode*, EPIN* epin, int gateNumber);
LIB_TEXT* loadSymboltext( std::unique_ptr< LIB_PART >& aPart, wxXmlNode* aLibText, int gateNumber);
KIWAY* m_kiway; ///< For creating sub sheets.
SCH_SHEET* m_rootSheet; ///< The root sheet of the schematic being loaded..
@ -163,8 +166,8 @@ private:
wxFileName m_filename;
PART_LIB* m_partlib; ///< symbol library for imported file.
EPART_LIST m_partlist;
std::map<std::string, EAGLE_LIBRARY*> m_eaglelibraries;
EPART_MAP m_partlist;
std::map<std::string, EAGLE_LIBRARY> m_eaglelibraries;
EDA_RECT sheetBoundingBox;
std::map<std::string, int > m_NetCounts;

2
include/eagle_parser.h
View File

@ -51,7 +51,7 @@ struct EPART;
typedef std::unordered_map<string, wxXmlNode*> NODE_MAP;
typedef std::map<string, MODULE*> MODULE_MAP;
typedef std::map<string, EINSTANCE*> EINSTANCE_MAP;
typedef std::map<string, EPART*> EPART_MAP;
typedef std::map<string, std::unique_ptr<EPART>> EPART_MAP;
static inline wxXmlNode* getChildrenNodes( NODE_MAP& aMap, const string& aName )
{