From 632d45e8336b48620b41d8f371bd4e6b71d9c01e Mon Sep 17 00:00:00 2001 From: Roberto Fernandez Bautista Date: Mon, 3 Aug 2020 23:07:07 +0100 Subject: [PATCH] CADSTAR PCB Archive Importer: Parse PARTS section --- pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb.h | 2 +- .../cadstar_pcb_archive_parser.cpp | 305 +++++++++++++++++- .../cadstar_pcb_archive_parser.h | 204 +++++++++++- qa/libeval_compiler/CMakeLists.txt | 1 + 4 files changed, 502 insertions(+), 10 deletions(-) diff --git a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb.h b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb.h index 3a8ca8b754..5de290a412 100644 --- a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb.h +++ b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb.h @@ -46,7 +46,7 @@ public: private: BOARD* mBoard; std::map mLayermap; // mCopperLayers; + std::map mCopperLayers; void loadBoardStackup(); PCB_LAYER_ID getKiCadCopperLayerID( unsigned int aLayerNum ); }; diff --git a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.cpp b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.cpp index 08d6e2a868..33581e46db 100644 --- a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.cpp +++ b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.cpp @@ -58,6 +58,12 @@ void CADSTAR_PCB_ARCHIVE_PARSER::Parse() Assignments.Parse( cNode ); else if( cNode->GetName() == wxT( "LIBRARY" ) ) Library.Parse( cNode ); + else if( cNode->GetName() == wxT( "DEFAULTS" ) ) + { + //No useful design information here (no need to parse) + } + else if( cNode->GetName() == wxT( "PARTS" ) ) + Parts.Parse( cNode ); //TODO need to parse everything else! } @@ -1183,6 +1189,16 @@ void CADSTAR_PCB_ARCHIVE_PARSER::ATTRIBUTE_VALUE::Parse( XNODE* aNode ) AttributeID = GetXmlAttributeIDString( aNode, 0 ); Value = GetXmlAttributeIDString( aNode, 1 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + if( cNode->GetName() == wxT( "READONLY" ) ) + ReadOnly = true; + else + THROW_UNKNOWN_NODE_IO_ERROR( cNode->GetName(), wxT( "ATTR" ) ); + } } @@ -1603,7 +1619,7 @@ void CADSTAR_PCB_ARCHIVE_PARSER::PAD::Parse( XNODE* aNode ) wxString location = wxString::Format( "PAD %d", ID ); if( !cNode ) - THROW_MISSING_NODE_IO_ERROR( wxT( "PADIDENTIFIER" ), location ); + THROW_MISSING_NODE_IO_ERROR( wxT( "PT" ), location ); for( ; cNode; cNode = cNode->GetNext() ) { @@ -2182,3 +2198,290 @@ void CADSTAR_PCB_ARCHIVE_PARSER::LIBRARY::Parse( XNODE* aNode ) } } } + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::GATE::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "GATEDEFINITION" ) ); + + ID = GetXmlAttributeIDString( aNode, 0 ); + Name = GetXmlAttributeIDString( aNode, 1 ); + Alternate = GetXmlAttributeIDString( aNode, 2 ); + PinCount = GetXmlAttributeIDLong( aNode, 3 ); + + CheckNoChildNodes( aNode ); +} + +CADSTAR_PCB_ARCHIVE_PARSER::PART::PIN_TYPE CADSTAR_PCB_ARCHIVE_PARSER::PART::GetPinType( + XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PINTYPE" ) ); + + wxString pinTypeStr = GetXmlAttributeIDString( aNode, 0 ); + + std::map pinTypeMap = { + { wxT( "INPUT" ), PIN_TYPE::INPUT }, //////////////////////////////// + { wxT( "OUTPUT_OR" ), PIN_TYPE::OUTPUT_OR }, //////////////////////////////// + { wxT( "OUTPUT_NOT_OR" ), PIN_TYPE::OUTPUT_NOT_OR }, //////////////////////////////// + { wxT( "OUTPUT_NOT_NORM_OR" ), PIN_TYPE::OUTPUT_NOT_NORM_OR }, ////////////////////// + { wxT( "POWER" ), PIN_TYPE::POWER }, ////////////////////////////////////////////// + { wxT( "GROUND" ), PIN_TYPE::GROUND }, ////////////////////////////////////////////// + { wxT( "TRISTATE_BIDIR" ), PIN_TYPE::TRISTATE_BIDIR }, ///////////////////////////// + { wxT( "TRISTATE_INPUT" ), PIN_TYPE::TRISTATE_INPUT }, ///////////////////////////// + { wxT( "TRISTATE_DRIVER" ), PIN_TYPE::TRISTATE_DRIVER } ///////////////////////////// + }; + + if( pinTypeMap.find( pinTypeStr ) == pinTypeMap.end() ) + THROW_UNKNOWN_PARAMETER_IO_ERROR( pinTypeStr, aNode->GetName() ); + + return pinTypeMap[pinTypeStr]; +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::PIN::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PARTDEFINITIONPIN" ) ); + + ID = GetXmlAttributeIDLong( aNode, 0 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "PINNAME" ) ) + Name = GetXmlAttributeIDString( cNode, 0 ); + else if( cNodeName == wxT( "PINLABEL" ) ) + Label = GetXmlAttributeIDString( cNode, 0 ); + else if( cNodeName == wxT( "PINSIGNAL" ) ) + Signal = GetXmlAttributeIDString( cNode, 0 ); + else if( cNodeName == wxT( "PINTERM" ) ) + { + TerminalGate = GetXmlAttributeIDString( cNode, 0 ); + TerminalPin = GetXmlAttributeIDLong( cNode, 1 ); + } + else if( cNodeName == wxT( "PINTYPE" ) ) + Type = GetPinType( cNode ); + else if( cNodeName == wxT( "PINLOAD" ) ) + Load = GetXmlAttributeIDLong( cNode, 0 ); + else if( cNodeName == wxT( "PINPOSITION" ) ) + Position = (POSITION) GetXmlAttributeIDLong( cNode, 0 ); + else if( cNodeName == wxT( "PINIDENTIFIER" ) ) + Identifier = GetXmlAttributeIDString( cNode, 0 ); + else + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::PART_PIN::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PARTPIN" ) ); + + ID = GetXmlAttributeIDLong( aNode, 0 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "PINNAME" ) ) + Name = GetXmlAttributeIDString( cNode, 0 ); + else if( cNodeName == wxT( "PINTYPE" ) ) + Type = GetPinType( cNode ); + else if( cNodeName == wxT( "PINIDENTIFIER" ) ) + Identifier = GetXmlAttributeIDString( cNode, 0 ); + else + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } +} + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::PIN_EQUIVALENCE::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PINEQUIVALENCE" ) ); + + wxXmlAttribute* xmlAttribute = aNode->GetAttributes(); + + for( ; xmlAttribute; xmlAttribute = xmlAttribute->GetNext() ) + { + long pinId; + + if( !xmlAttribute->GetValue().ToLong( &pinId ) ) + THROW_UNKNOWN_PARAMETER_IO_ERROR( xmlAttribute->GetValue(), aNode->GetName() ); + + PinIDs.push_back( (PART_DEFINITION_PIN_ID) pinId ); + } + + CheckNoChildNodes( aNode ); +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::SWAP_GATE::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "SWAPGATE" ) ); + + wxXmlAttribute* xmlAttribute = aNode->GetAttributes(); + + for( ; xmlAttribute; xmlAttribute = xmlAttribute->GetNext() ) + { + long pinId; + + if( !xmlAttribute->GetValue().ToLong( &pinId ) ) + THROW_UNKNOWN_PARAMETER_IO_ERROR( xmlAttribute->GetValue(), aNode->GetName() ); + + PinIDs.push_back( (PART_DEFINITION_PIN_ID) pinId ); + } + + CheckNoChildNodes( aNode ); +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::SWAP_GROUP::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "SWAPGROUP" ) ); + + GateName = GetXmlAttributeIDString( aNode, 0 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "EXTERNAL" ) ) + External = true; + else if( cNodeName == wxT( "SWAPGATE" ) ) + { + SWAP_GATE swapGate; + //TODO try.. catch + throw again with more detailed error information + swapGate.Parse( cNode ); + SwapGates.push_back( swapGate ); + } + else + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::DEFINITION::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PARTDEFINITION" ) ); + + Name = GetXmlAttributeIDString( aNode, 0 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "HIDEPINNAMES" ) ) + HidePinNames = true; + else if( cNodeName == wxT( "MAXPIN" ) ) + MaxPinCount = GetXmlAttributeIDLong( cNode, 0 ); + else if( cNodeName == wxT( "GATEDEFINITION" ) ) + { + GATE gate; + //TODO try.. catch + throw again with more detailed error information + gate.Parse( cNode ); + GateSymbols.insert( std::make_pair(gate.ID, gate) ); + } + else if( cNodeName == wxT( "PARTDEFINITIONPIN" ) ) + { + PIN pin; + //TODO try.. catch + throw again with more detailed error information + pin.Parse( cNode ); + Pins.insert( std::make_pair( pin.ID, pin ) ); + } + else if( cNodeName == wxT( "ATTR" ) ) + { + ATTRIBUTE_VALUE attr; + //TODO try.. catch + throw again with more detailed error information + attr.Parse( cNode ); + AttributeValues.insert( std::make_pair( attr.AttributeID, attr ) ); + } + else if( cNodeName == wxT( "PINEQUIVALENCE" ) ) + { + PIN_EQUIVALENCE pinEq; + //TODO try.. catch + throw again with more detailed error information + pinEq.Parse( cNode ); + PinEquivalences.push_back( pinEq ); + } + else if( cNodeName == wxT( "SWAPGROUP" ) ) + { + SWAP_GROUP swapGroup; + //TODO try.. catch + throw again with more detailed error information + swapGroup.Parse( cNode ); + SwapGroups.push_back( swapGroup ); + } + else + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PART::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PART" ) ); + + ID = GetXmlAttributeIDString( aNode, 0 ); + Name = GetXmlAttributeIDString( aNode, 1 ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "VERSION" ) ) + Version = GetXmlAttributeIDLong( cNode, 0 ); + else if( cNodeName == wxT( "PARTDEFINITION" ) ) + { + //TODO try.. catch + throw again with more detailed error information + Definition.Parse( cNode ); + } + else if( cNodeName == wxT( "PARTPIN" ) ) + { + PART_PIN pin; + //TODO try.. catch + throw again with more detailed error information + pin.Parse( cNode ); + PartPins.insert( std::make_pair( pin.ID, pin ) ); + } + else if( cNodeName == wxT( "ATTR" ) ) + { + ATTRIBUTE_VALUE attr; + //TODO try.. catch + throw again with more detailed error information + attr.Parse( cNode ); + AttributeValues.insert( std::make_pair( attr.AttributeID, attr ) ); + } + else + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } +} + + +void CADSTAR_PCB_ARCHIVE_PARSER::PARTS::Parse( XNODE* aNode ) +{ + wxASSERT( aNode->GetName() == wxT( "PARTS" ) ); + + XNODE* cNode = aNode->GetChildren(); + + for( ; cNode; cNode = cNode->GetNext() ) + { + wxString cNodeName = cNode->GetName(); + + if( cNodeName == wxT( "PART" ) ) + { + PART part; + //TODO try.. catch + throw again with more detailed error information + part.Parse( cNode ); + PartDefinitions.insert( std::make_pair( part.ID, part ) ); + } + else + { + THROW_UNKNOWN_NODE_IO_ERROR( cNodeName, aNode->GetName() ); + } + } +} diff --git a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.h b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.h index 43ce0338be..cbf033b6da 100644 --- a/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.h +++ b/pcbnew/cadstar2kicadpcb_plugin/cadstar_pcb_archive_parser.h @@ -37,7 +37,7 @@ //================================= #define UNDEFINED_LAYER_ID ( LAYER_ID ) wxEmptyString #define UNDEFINED_MATERIAL_ID ( MATERIAL_ID ) wxEmptyString -#define UNDEFINED_PHYSICAL_LAYER ( PHYSICAL_LAYER ) - 1 +#define UNDEFINED_PHYSICAL_LAYER ( PHYSICAL_LAYER_ID ) - 1 /** * Default spacing class for all nets @@ -78,7 +78,7 @@ public: typedef wxString MATERIAL_ID; typedef wxString LAYER_ID; - typedef long PHYSICAL_LAYER; + typedef long PHYSICAL_LAYER_ID; typedef wxString LINECODE_ID; typedef wxString HATCHCODE_ID; typedef wxString TEXTCODE_ID; @@ -92,10 +92,15 @@ public: typedef wxString SPACING_CLASS_ID; typedef wxString FIGURE_ID; typedef wxString COMP_AREA_ID; - typedef long PAD_ID; + typedef long PAD_ID; ///< Pad identifier (pin) in the PCB typedef wxString TEXT_ID; typedef wxString DIMENSION_ID; typedef wxString SYMDEF_ID; + typedef wxString PART_ID; + typedef wxString GATE_ID; + typedef long TERMINAL_ID; ///< Terminal is the pin identifier in the schematic + typedef long PART_DEFINITION_PIN_ID; ///< Pin identifier in the part definition + typedef long PART_PIN_ID; ///< Pin identifier in the part //================================= @@ -229,7 +234,7 @@ public: wxString Name; LAYER_TYPE Type = LAYER_TYPE::UNDEFINED; LAYER_SUBTYPE SubType = LAYER_SUBTYPE::LAYERSUBTYPE_NONE; - PHYSICAL_LAYER PhysicalLayer = + PHYSICAL_LAYER_ID PhysicalLayer = UNDEFINED_PHYSICAL_LAYER; ///< If UNDEFINED, no physical layer is ///< assigned (e.g. documentation and ///< construction layers) @@ -463,8 +468,8 @@ public: { LAYERPAIR_ID ID; wxString Name; - PHYSICAL_LAYER PhysicalLayerStart; - PHYSICAL_LAYER PhysicalLayerEnd; + PHYSICAL_LAYER_ID PhysicalLayerStart; + PHYSICAL_LAYER_ID PhysicalLayerEnd; VIACODE_ID ViacodeID; void Parse( XNODE* aNode ); @@ -514,7 +519,10 @@ public: struct ATTRNAME { ATTRIBUTE_ID ID; - wxString Name; + wxString Name; ///< Parenthesis aren't permitted in user attributes in CADSTAR. Any + ///< Attributes in Parenthesis indicate an internal CADSTAR attribute + ///< Examples: "(PartDescription)" "(PartDefinitionNameStem)",etc. + ///TODO: create a list of all CADSTAR internal attribute names. ATTROWNER AttributeOwner = ATTROWNER::ALL_ITEMS; ATTRUSAGE AttributeUsage = ATTRUSAGE::UNDEFINED; bool NoTransfer = false; ///< True="All Design Types", False="Current Design Type" @@ -533,6 +541,7 @@ public: { ATTRIBUTE_ID AttributeID; wxString Value; + bool ReadOnly = false; void Parse( XNODE* aNode ); }; @@ -836,6 +845,7 @@ public: ///< and replace. It replaces the CADSTAR 13.0 pad sequence ///< number but is much less restrictive i.e. It need not be 1, 2, ///< 3 etc. and can contain alpha and / or numeric characters." + bool FirstPad = false; ///< From CADSTAR Help: "Only one pad can have this property; if an ///< existing pad in the design already has this property it will be ///< removed from the existing pad when this new pad is added. The @@ -887,7 +897,7 @@ public: /** * @brief From CADSTAR Help: "Multi Line Text can also be justified as Left, Centre or Right. * This does not affect the text alignment. Note: Justification of single line text has no - * affect." + * effect." * * This only affects multiline text * @@ -1212,11 +1222,189 @@ public: void Parse( XNODE* aNode ); }; + struct PART + { + enum class PIN_TYPE + { + UNCOMMITTED, ///< Uncomitted pin (default) + INPUT, ///< Input pin + OUTPUT_OR, ///< Output pin OR tieable + OUTPUT_NOT_OR, ///< Output pin not OR tieable + OUTPUT_NOT_NORM_OR, ///< Output pin not normally OR tieable + POWER, ///< Power pin + GROUND, ///< Ground pin + TRISTATE_BIDIR, ///< Tristate bi-directional driver pin + TRISTATE_INPUT, ///< Tristate input pin + TRISTATE_DRIVER ///< Tristate output pin + }; + + static PIN_TYPE GetPinType( XNODE* aNode ); + + struct DEFINITION ///< "PARTDEFINITION" node name + { + struct GATE ///< "GATEDEFINITION" node name + { + GATE_ID ID; ///< Usually "A", "B", "C", etc. + wxString Name; ///< Symbol name in the symbol library + wxString Alternate; ///< Symbol alternate name in the symbol library + long PinCount; ///< Number of pins (terminals) in the symbol + + void Parse( XNODE* aNode ); + }; + + + struct PIN ///< "PARTDEFINITIONPIN" node name + { + /** + * @brief Positioning of pin names can be in one of four quadrants + */ + enum class POSITION + { + TOP_RIGHT = 0, ///< Default + TOP_LEFT = 1, + BOTTOM_LEFT = 2, + BOTTOM_RIGHT = 3 + }; + + PART_DEFINITION_PIN_ID ID; + wxString Name = wxEmptyString; ///< Can be empty. If empty the pin name + ///< displayed wil be Identifier + ///< (subnode="PINNAME") + wxString Label = wxEmptyString; ///< Can be empty (subnode="PINLABEL") + wxString Signal = wxEmptyString; ///< Usually for Power/Ground pins, + ///< (subnode="PINSIGNAL") + GATE_ID TerminalGate; ///< (subnode="PINTERM", param0) + TERMINAL_ID TerminalPin; ///< (subnode="PINTERM", param1) + PIN_TYPE Type = PIN_TYPE::UNCOMMITTED; ///< subnode="PINTYPE" + long Load = UNDEFINED_VALUE; ///< The electrical current expected on + ///< the pin (It is unclear what the units + ///< are, but only accepted values are + ///< integers) subnode ="PINLOAD" + POSITION Position = + POSITION::TOP_RIGHT; ///< The pin names will use these positions when + ///< the symbol is added to a schematic design + ///< subnode="PINPOSITION" + + wxString Identifier = + wxEmptyString; ///< This should match a pad identifier in the component + ///< footprint subnode="PINIDENTIFIER". It is assumed that + ///< this could be empty in earlier versions of CADSTAR + + void Parse( XNODE* aNode ); + }; + + struct PIN_EQUIVALENCE ///< "PINEQUIVALENCE" Node name (represents "Equivalence") + { + std::vector PinIDs; ///< All the pins in this vector are + ///< equivalent and can be swapped with + ///< each other + + void Parse( XNODE* aNode ); + }; + + + struct SWAP_GATE ///< "SWAPGATE" Node name (represents an "Element") + { + std::vector PinIDs; ///< The pins in this vector + ///< describe a "gate" + + void Parse( XNODE* aNode ); + }; + + struct SWAP_GROUP + { + wxString GateName = wxEmptyString; ///< Optional. If not empty, should match the Name + ///< attribute of one of the gates defined in the + ///< part definition + + bool External = false; ///< Determines if this swap group is external (and internal) + ///< or internal only. External Gate swapping allows Gates on + ///< different components with the same Part Definition to + ///< swap with one another. + ///< + ///< The external swapping groups must be at the root level + ///< (i.e. they cannot be contained by other swapping groups) + + std::vector SwapGates; ///< Each of the elements in this vector can be + ///< swapped with each other - i.e. *all* of the + ///< pins in each swap gate can be swapped with + ///< *all* in another swap gate defined in this + ///< vector + + void Parse( XNODE* aNode ); + }; + + wxString Name; ///< This name can be different to the PART name + bool HidePinNames; ///< Specifies whether to display the pin names/indentifier in + ///< the schematic symbol or not. E.g. it is useful to display + ///< pin name information for integrated circuits but less so + ///< for resistors and capacitors. (subnode HIDEPINNAMES) + + long MaxPinCount = + UNDEFINED_VALUE; ///< Optional parameter which is used for specifying the number + ///< of electrical pins on the PCB component symbol to be + ///< used in the part definition (this should not include + ///< mechanical pins for fixing etc.). This value must be less + ///< than or equal to than the number of pins on the PCB + ///< Component symbol. + + std::map GateSymbols; + std::map Pins; + std::map AttributeValues; ///< Some attributes are + ///< defined within the part + ///< definition, whilst others + ///< are defined in the part + std::vector PinEquivalences; + std::vector SwapGroups; + + void Parse( XNODE* aNode ); + }; + + + struct PART_PIN ///< "PARTPIN" node name + { + PART_PIN_ID ID; + wxString Name = wxEmptyString; + PIN_TYPE Type = PIN_TYPE::UNCOMMITTED; + wxString Identifier = wxEmptyString; + + void Parse( XNODE* aNode ); + }; + + + PART_ID ID; + wxString Name; + long Version; + DEFINITION Definition; + std::map PartPins; ///< It is unclear why there are two "Pin" + ///< structures in CPA files... PART_PIN seems to + ///< be a reduced version of PART::DEFINITION::PIN + ///< Therefore, PART_PIN is only included for + ///< completeness of the parser, but won't be used + + + std::map AttributeValues; ///< Some attributes are defined + ///< within the part definition, + ///< whilst others are defined in + ///< the part itself + + void Parse( XNODE* aNode ); + }; + + struct PARTS + { + std::map PartDefinitions; + + void Parse( XNODE* aNode ); + }; + + wxString Filename; HEADER Header; ASSIGNMENTS Assignments; LIBRARY Library; + PARTS Parts; //TODO Add Library, Defaults, Parts, etc.. diff --git a/qa/libeval_compiler/CMakeLists.txt b/qa/libeval_compiler/CMakeLists.txt index 2223baf3ee..3a00a4853b 100644 --- a/qa/libeval_compiler/CMakeLists.txt +++ b/qa/libeval_compiler/CMakeLists.txt @@ -75,6 +75,7 @@ target_link_libraries( libeval_compiler_test pcbcommon bitmaps gal + cadstar2kicadpcb common pcbcommon ${PCBNEW_IO_LIBRARIES}