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, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#pragma once
 
#include <string>
#include <vector>
#include <map>
#include <optional>
#include <wx/string.h>
#include <wx/gdicmn.h> // For wxPoint if needed, or use VECTOR2I
#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;                
 
    // Thermal relief settings (global defaults)
    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;            
 
    // Drill parameters
    double drill_oversize = 0.0;           
 
    // Via defaults extracted from file
    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;
};

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;    
 
    // Slotted drill parameters
    double slot_orientation = 0.0; 
    double slot_length = 0.0;      
    double slot_offset = 0.0;      
 
    // Thermal pad parameters (for 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;             
};
 
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; // Via type name
    POINT location;
};

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 relief definitions (PADTHERM, VIATHERM)
    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;
};

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; 
};

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();
 
    // Helper to read next line skipping comments and empty lines
    bool readLine( std::ifstream& aStream, std::string& aLine );
    void pushBackLine( const std::string& aLine );
 
    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;
 
    std::string m_current_section;
    std::optional<std::string> m_pushed_line;
};
 
} // namespace PADS_IO