pads_parser.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2025 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <string>
#include <vector>
#include <map>
#include <optional>
#include <wx/string.h>
#include <wx/gdicmn.h>
#include <math/vector2d.h>
 
namespace PADS_IO
{
 
enum class UNIT_TYPE
{
    MILS,
    METRIC,
    INCHES
};
 
struct POINT
{
    double x;
    double y;
};

struct ARC
{
    double cx;
    double cy;
    double radius;
    double start_angle;
    double delta_angle;
};

struct ARC_POINT
{
    double x;
    double y;
    bool   is_arc;
    ARC    arc;          
 
    ARC_POINT() :
            x( 0 ),
            y( 0 ),
            is_arc( false ),
            arc{ 0, 0, 0, 0, 0 }
    {
    }
    ARC_POINT( double aX, double aY ) :
            x( aX ),
            y( aY ),
            is_arc( false ),
            arc{ 0, 0, 0, 0, 0 }
    {
    }
    ARC_POINT( double aX, double aY, const ARC& aArc ) :
            x( aX ),
            y( aY ),
            is_arc( true ),
            arc( aArc )
    {
    }
};
 
enum class PADS_FILE_TYPE
{
    PCB,
    LIB_LINE,       
    LIB_SCH_DECAL,
    LIB_PCB_DECAL,  
    LIB_PART_TYPE
};
 
struct FILE_HEADER
{
    std::string product;                
    std::string version;
    std::string units;                  
    std::string mode;
    std::string encoding;
    PADS_FILE_TYPE file_type = PADS_FILE_TYPE::PCB;
};
 
struct PARAMETERS
{
    UNIT_TYPE units = UNIT_TYPE::MILS;
    int layer_count = 2;
    POINT origin = {0, 0};
    double user_grid = 0.0;                
 
    double thermal_line_width = 30.0;      
    double thermal_smd_width = 20.0;       
    int thermal_flags = 0;                 
    double thermal_min_clearance = 5.0;    
    int thermal_min_spokes = 4;            
 
    double drill_oversize = 0.0;           
 
    std::string default_signal_via;        
};
 
struct DESIGN_RULES
{
    double min_clearance = 8.0;           
    double default_clearance = 10.0;      
    double min_track_width = 6.0;         
    double default_track_width = 10.0;    
    double min_via_size = 20.0;           
    double default_via_size = 40.0;       
    double min_via_drill = 10.0;          
    double default_via_drill = 20.0;      
    double hole_to_hole = 10.0;           
    double silk_clearance = 5.0;          
    double mask_clearance = 3.0;          
    double copper_edge_clearance = 10.0;  
};
 
struct ATTRIBUTE
{
    // Line 1
    bool visible = true;
    double x = 0.0;
    double y = 0.0;
    double orientation = 0.0;
    int level = 0;
    double height = 0.0;
    double width = 0.0;
    bool mirrored = false;
    std::string hjust;
    std::string vjust;
    bool right_reading = false;
 
    // Line 2
    std::string font_info;
 
    // Line 3
    std::string name; // "Ref.Des.", "Part Type", "VALUE", etc.
};
 
struct PART
{
    std::string name;
    std::string decal;                         
    std::string part_type;                     
    std::vector<std::string> alternate_decals; 
    int alt_decal_index = -1;                  
    std::string value;
    std::string units;
    POINT location;
    double rotation = 0.0;
    bool bottom_layer = false;
    bool glued = false;
    bool explicit_decal = false;               
    std::vector<ATTRIBUTE> attributes;
    std::string reuse_instance;
    std::string reuse_part;                    
};
 
struct NET_PIN
{
    std::string ref_des;
    std::string pin_name;
    std::string reuse_instance;
    std::string reuse_signal;
};
 
struct NET
{
    std::string name;
    std::vector<NET_PIN> pins;
    std::vector<std::string> component_refs; 
};
 
struct NET_CLASS_DEF
{
    std::string name;
    double clearance = 0.0;                 
    double track_width = 0.0;               
    double via_size = 0.0;                  
    double via_drill = 0.0;                 
    double diff_pair_gap = 0.0;             
    double diff_pair_width = 0.0;           
    std::vector<std::string> net_names;
};
 
struct DIFF_PAIR_DEF
{
    std::string name;
    std::string positive_net;
    std::string negative_net;
    double gap = 0.0;
    double width = 0.0;
};
 
struct TEARDROP
{
    double pad_width = 0.0;
    double pad_length = 0.0;
    int pad_flags = 0;
    double net_width = 0.0;
    double net_length = 0.0;
    int net_flags = 0;
    bool has_pad_teardrop = false;
    bool has_net_teardrop = false;
};
 
struct JUMPER_MARKER
{
    std::string name;
    bool is_start = false;        
    double x = 0.0;
    double y = 0.0;
};
 
struct JUMPER_DEF
{
    std::string name;
    bool via_enabled = false;       
    bool wirebond = false;          
    bool display_silk = false;      
    bool glued = false;             
    double min_length = 0.0;
    double max_length = 0.0;
    double length_increment = 0.0;
    std::string padstack;           
    std::string end_padstack;       
    std::vector<ATTRIBUTE> labels;
};
 
struct TRACK
{
    int layer = 0;
    double width = 0.0;
    std::vector<ARC_POINT> points;
};
 
struct PAD_STACK_LAYER
{
    int layer = 0;
    std::string shape;       
    double sizeA = 0.0;      
    double sizeB = 0.0;      
    double offsetX = 0.0;
    double offsetY = 0.0;
    double rotation = 0.0;
    double drill = 0.0;      
    bool plated = true;      
    double inner_diameter = 0.0;   
    double corner_radius = 0.0;    
    bool chamfered = false;        
    double finger_offset = 0.0;    
 
    double slot_orientation = 0.0; 
    double slot_length = 0.0;
    double slot_offset = 0.0;      
 
    // RT/ST shapes
    double thermal_spoke_orientation = 0.0;  
    double thermal_outer_diameter = 0.0;     
    double thermal_spoke_width = 0.0;
    int thermal_spoke_count = 0;
};

bool IsThermalReliefPadRow( const PAD_STACK_LAYER& aLayer );

bool IsAntiPadRow( const PAD_STACK_LAYER& aLayer );

bool IsCopperPadRow( const PAD_STACK_LAYER& aLayer );
 
enum class VIA_TYPE
{
    THROUGH,    
    BLIND,      
    BURIED,     
    MICROVIA    
};
 
struct VIA_DEF
{
    std::string name;
    double drill = 0.0;
    double size = 0.0;
    std::vector<PAD_STACK_LAYER> stack;
    int start_layer = 0;     
    int end_layer = 0;       
    VIA_TYPE via_type = VIA_TYPE::THROUGH;
    int drill_start = 0;     
    int drill_end = 0;
    bool has_mask_front = false;  
    bool has_mask_back = false;   
};
 
struct VIA
{
    std::string name;
    POINT location;
    std::vector<PAD_STACK_LAYER> stack;
    int                          start_layer = 0;
    int                          end_layer = 0;
};
 
enum class POUR_STYLE
{
    SOLID,      
    HATCHED,    
    VOIDOUT
};
 
enum class THERMAL_TYPE
{
    NONE,
    PAD,        
    VIA         
};
 
struct POUR
{
    std::string name;
    std::string net_name;
    int layer = 0;
    int priority = 0;
    double width = 0.0;
    std::vector<ARC_POINT> points;
    bool is_cutout = false;             
    std::string owner_pour;             
    POUR_STYLE style = POUR_STYLE::SOLID;
    double hatch_grid = 0.0;
    double hatch_width = 0.0;
 
    THERMAL_TYPE thermal_type = THERMAL_TYPE::NONE;
    double thermal_spoke_width = 0.0;
    int thermal_spoke_count = 4;
    double thermal_gap = 0.0;
};
 
struct DECAL_ITEM
{
    std::string type;               
    int layer = 0;
    double width = 0.0;
    std::vector<ARC_POINT> points;
    int pinnum = -1;                
    std::string restrictions;       
    bool is_tag_open = false;       
    bool is_tag_close = false;      
};
 
struct DECAL_PAD
{
    int pin_number; // 0 for default
    POINT position;
    std::string name; // e.g. "1", "A1"
    std::vector<PAD_STACK_LAYER> stack;
    bool custom_stack = false;
};
 
 
struct TERMINAL
{
    double x;
    double y;
    std::string name; // Pin number
};
 
struct PART_DECAL
{
    std::string name;
    std::string units; // M, I, U, etc.
    std::vector<DECAL_ITEM> items;
    std::vector<ATTRIBUTE> attributes;
    std::vector<TERMINAL> terminals;
    std::map<int, std::vector<PAD_STACK_LAYER>> pad_stacks;
    std::map<int, std::pair<int, int>> drill_spans;
};
 
struct SIGPIN
{
    std::string pin_number;
    double width = 0.0;         
    std::string signal_name;    
};
 
enum class PIN_ELEC_TYPE
{
    UNDEFINED,      
    SOURCE,         
    BIDIRECTIONAL,  
    OPEN_COLLECTOR, 
    TRISTATE,       
    LOAD,           
    TERMINATOR,     
    POWER,          
    GROUND          
};
 
struct GATE_PIN
{
    std::string pin_number;
    int swap_type = 0;                  
    PIN_ELEC_TYPE elec_type = PIN_ELEC_TYPE::UNDEFINED;
    std::string func_name;
};
 
struct GATE_DEF
{
    int gate_swap_type = 0;             
    std::vector<GATE_PIN> pins;
};
 
struct PART_TYPE
{
    std::string name;
    std::string decal_name;
    std::map<std::string, int> pin_pad_map;       
    std::map<std::string, std::string> attributes; 
    std::vector<SIGPIN> signal_pins;
    std::vector<GATE_DEF> gates;
};
 
struct ROUTE
{
    std::string net_name;
    std::vector<TRACK> tracks;
    std::vector<VIA> vias;
    std::vector<NET_PIN> pins;             
    std::vector<TEARDROP> teardrops;
    std::vector<JUMPER_MARKER> jumpers;
};
 
struct TEXT
{
    std::string content;
    POINT location;
    double height = 0.0;
    double width = 0.0;
    int layer = 0;
    double rotation = 0.0;
    bool mirrored = false;
    std::string hjust;            
    std::string vjust;            
    int ndim = 0;                 
    std::string reuse_instance;
    std::string font_style;       
    double font_height = 0.0;
    double font_descent = 0.0;
    std::string font_face;
};
 
struct LINE
{
    int layer;
    double width;
    POINT start;
    POINT end;
};
 
enum class LINE_STYLE
{
    SOLID = 0,
    DASHED = 1,
    DOTTED = 2,
    DASH_DOTTED = 3,
    DASH_DOUBLE_DOTTED = 4
};

struct GRAPHIC_LINE
{
    std::string name;
    int layer = 0;
    double width = 0.0;
    LINE_STYLE style = LINE_STYLE::SOLID;
    bool closed = false;
    bool filled = false;
    std::vector<ARC_POINT> points;
    std::string reuse_instance;
};

struct POLYLINE
{
    int layer;
    double width;
    bool closed;
    std::vector<ARC_POINT> points;
};
 
struct BOARD_ITEM
{
    // Base for board outline, etc.
};

struct COPPER_SHAPE
{
    std::string name;
    std::string net_name;               
    int layer = 0;
    double width = 0.0;                 
    bool filled = false;                
    bool is_cutout = false;             
    std::vector<ARC_POINT> outline;
};
 
enum class PADS_LAYER_FUNCTION
{
    UNKNOWN,
    ROUTING,
    PLANE,
    MIXED,
    UNASSIGNED,
    SOLDER_MASK,
    PASTE_MASK,
    SILK_SCREEN,
    ASSEMBLY,
    DOCUMENTATION,
    DRILL
};
 
struct LAYER_INFO
{
    int                  number;      
    std::string          name;
    PADS_LAYER_FUNCTION  layer_type;
    bool                 is_copper;
    bool                 required;    
    double               layer_thickness = 0.0;     
    double               copper_thickness = 0.0;    
    double               dielectric_constant = 0.0; 
    int                  routing_direction = -1;    
};
 
struct REUSE_NET
{
    bool merge = false;        
    std::string name;          
};
 
struct REUSE_INSTANCE
{
    std::string instance_name;
    std::string part_naming;       
    std::string net_naming;        
    POINT location = {};
    double rotation = 0.0;
    bool glued = false;
};

struct REUSE_BLOCK
{
    std::string name;
    long timestamp = 0;
    std::string part_naming;                    
    std::string net_naming;                     
    std::vector<std::string> part_names;
    std::vector<REUSE_NET> nets;
    std::vector<REUSE_INSTANCE> instances;       
};
 
struct CLUSTER
{
    std::string name;
    int id = 0;
    std::vector<std::string> net_names;
    std::vector<std::string> segment_refs;
};
 
struct TEST_POINT
{
    std::string type;           
    double x = 0.0;
    double y = 0.0;
    int side = 0;               
    std::string net_name;
    std::string symbol_name;
};
 
struct DIMENSION
{
    std::string name;
    double x = 0.0;                     
    double y = 0.0;
    double crossbar_pos = 0.0;          
    bool is_horizontal = true;
    int layer = 0;
    std::vector<POINT> points;          
    std::string text;
    double text_height = 0.0;
    double text_width = 0.0;
    double rotation = 0.0;
};
 
enum class KEEPOUT_TYPE
{
    ALL,
    ROUTE,
    VIA,
    COPPER,
    PLACEMENT
};
 
struct KEEPOUT
{
    KEEPOUT_TYPE type = KEEPOUT_TYPE::ALL;
    std::vector<ARC_POINT> outline;
    std::vector<int> layers;                
    bool no_traces = true;                  
    bool no_vias = true;                    
    bool no_copper = true;                  
    bool no_components = false;             
    bool height_restriction = false;        
    double max_height = 0.0;
    bool no_test_points = false;            
    bool no_accordion = false;              
};
 
class PARSER
{
public:
    PARSER();
    ~PARSER();
 
    void Parse( const wxString& aFileName );
 
    const PARAMETERS& GetParameters() const { return m_parameters; }
    const std::vector<PART>& GetParts() const { return m_parts; }
    const std::vector<NET>& GetNets() const { return m_nets; }
    const std::vector<ROUTE>& GetRoutes() const { return m_routes; }
    const std::vector<TEXT>& GetTexts() const { return m_texts; }
    const std::vector<LINE>& GetLines() const { return m_lines; }
    const std::vector<POLYLINE>& GetBoardOutlines() const { return m_board_outlines; }
    const std::vector<POUR>& GetPours() const { return m_pours; }
    const std::map<std::string, VIA_DEF>& GetViaDefs() const { return m_via_defs; }
    const std::map<std::string, PART_DECAL>& GetPartDecals() const { return m_decals; }
    const std::map<std::string, PART_TYPE>& GetPartTypes() const { return m_part_types; }
    const std::map<std::string, std::map<std::string, std::string>>& GetPartInstanceAttrs() const
    {
        return m_part_instance_attrs;
    }
    const std::map<std::string, REUSE_BLOCK>& GetReuseBlocks() const { return m_reuse_blocks; }
    const std::vector<CLUSTER>& GetClusters() const { return m_clusters; }
    const std::vector<TEST_POINT>& GetTestPoints() const { return m_test_points; }
    const std::vector<DIMENSION>& GetDimensions() const { return m_dimensions; }
    const DESIGN_RULES& GetDesignRules() const { return m_design_rules; }
    const std::vector<NET_CLASS_DEF>& GetNetClasses() const { return m_net_classes; }
    const std::vector<DIFF_PAIR_DEF>& GetDiffPairs() const { return m_diff_pairs; }
    const std::vector<KEEPOUT>& GetKeepouts() const { return m_keepouts; }
    const std::vector<JUMPER_DEF>& GetJumperDefs() const { return m_jumper_defs; }
    const std::vector<COPPER_SHAPE>& GetCopperShapes() const { return m_copper_shapes; }
    const std::vector<GRAPHIC_LINE>& GetGraphicLines() const { return m_graphic_lines; }
    const FILE_HEADER& GetFileHeader() const { return m_file_header; }
    bool IsBasicUnits() const { return m_is_basic_units; }

    std::vector<LAYER_INFO> GetLayerInfos() const;
 
private:
    void parseLine( const std::string& aLine );
    void parseSectionPCB( std::ifstream& aStream );
    void parseSectionPARTS( std::ifstream& aStream );
    void parseSectionNETS( std::ifstream& aStream );
    void parseSectionROUTES( std::ifstream& aStream );
    void parseSectionTEXT( std::ifstream& aStream );
    void parseSectionBOARD( std::ifstream& aStream );
    void parseSectionLINES( std::ifstream& aStream );
    void parseSectionVIA( std::ifstream& aStream );
    void parseSectionPOUR( std::ifstream& aStream );
    void parseSectionPARTDECAL( std::ifstream& aStream );
    void parseSectionPARTTYPE( std::ifstream& aStream );
    void parseSectionREUSE( std::ifstream& aStream );
    void parseSectionCLUSTER( std::ifstream& aStream );
    void parseSectionJUMPER( std::ifstream& aStream );
    void parseSectionTESTPOINT( std::ifstream& aStream );
    void parseSectionNETCLASS( std::ifstream& aStream );
    void parseSectionDIFFPAIR( std::ifstream& aStream );
    void parseSectionLAYERDEFS( std::ifstream& aStream );
    void parseSectionMISC( std::ifstream& aStream );
    void clampDesignRuleSentinels();
 
    // Read next line, skipping comments and empty lines
    bool readLine( std::ifstream& aStream, std::string& aLine );
    void pushBackLine( const std::string& aLine );

    int parseMajorVersion() const;
 
    PARAMETERS m_parameters;
    std::vector<PART> m_parts;
    std::vector<NET> m_nets;
    std::vector<ROUTE> m_routes;
    std::vector<TEXT> m_texts;
    std::vector<LINE> m_lines;
    std::vector<POLYLINE> m_board_outlines;
    std::vector<POUR> m_pours;
    std::map<std::string, VIA_DEF> m_via_defs;
    std::map<std::string, PART_DECAL> m_decals;
    std::map<std::string, PART_TYPE> m_part_types;

    std::map<std::string, std::map<std::string, std::string>> m_part_instance_attrs;
    std::map<std::string, REUSE_BLOCK> m_reuse_blocks;
    std::vector<CLUSTER> m_clusters;
    std::vector<TEST_POINT> m_test_points;
    std::vector<DIMENSION> m_dimensions;
    DESIGN_RULES m_design_rules;
    std::vector<NET_CLASS_DEF> m_net_classes;
    std::vector<DIFF_PAIR_DEF> m_diff_pairs;
    std::vector<KEEPOUT> m_keepouts;
    std::vector<JUMPER_DEF> m_jumper_defs;
    std::vector<COPPER_SHAPE> m_copper_shapes;
    std::vector<GRAPHIC_LINE> m_graphic_lines;
    std::map<int, LAYER_INFO> m_layer_defs;      
    FILE_HEADER m_file_header;
    bool m_is_basic_units = false;
    bool m_has_font_lines = true;            
 
    std::string m_current_section;
    std::optional<std::string> m_pushed_line;
};
 
} // namespace PADS_IO