target3001_parser.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The 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/>.
 */
 
#ifndef TARGET3001_PARSER_H
#define TARGET3001_PARSER_H
 
#include <array>
#include <cmath>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
#include <wx/datetime.h>
#include <wx/string.h>
 

namespace TARGET3001
{

enum class ELEMENT_TYPE : uint8_t
{
    LINE = 1,
    PIN = 2,
    PAD = 3,
    TRIANGLE = 4,
    RECTANGLE = 5,
    ARC = 6,
    DISC = 7,
    TEXT = 8,
    FIDUCIAL = 9,
    COMPONENT = 10,
    SYMBOL = 11,
    PACKAGE = 12,
    SIGNAL = 13,
    SPLINE = 14,
    DRC_MARKER = 15,
    LIST = 16,
    LAYER_FUNCTIONS = 17,
    NONE = 255
};
 

constexpr int SCHEMATIC_LAYER_BASE = 100;

constexpr int SCHEMATIC_SHEET_COUNT = 100;

constexpr int ALL_COPPER_LAYER = 100;
 

struct ELEMENT_BASE
{
    uint16_t component = 0;   
    uint16_t signal = 0;      
    int32_t  x = 0;
    int32_t  y = 0;
    uint8_t  flags = 0;
    uint8_t  status = 0;
    uint8_t  layer = 0;
    uint8_t  classTag = 0;    
 
    std::optional<uint32_t> extra;

    std::vector<std::pair<std::string, std::string>> props;

    const std::string* FindProp( const std::string& aKey ) const;

    bool FlagProp( const std::string& aKey ) const;

    std::optional<std::pair<int32_t, int32_t>> TextRightEnd() const;

    std::vector<uint8_t> Picture() const;
};
 
 
struct LINE
{
    int32_t x2 = 0;
    int32_t y2 = 0;
    int32_t width = 0;
    int32_t clearance = 0;
    uint8_t dashStyle = 0;    
    uint8_t roundEnds = 0;
};
 

struct PIN
{
    float    direction = 0.0f;
    int32_t  length = 0;
    int32_t  width = 0;
    uint8_t  electricalType = 0;
    uint16_t swapLevel = 0;
    uint8_t  inverted = 0;
    uint8_t  clock = 0;
    uint8_t  showNumber = 0;
    uint8_t  supplyPin = 0;
    uint16_t pinNumber = 0;
};
 
 
enum class PAD_SHAPE : uint8_t
{
    ROUND = 0,
    OCTAGON = 1,
    RECTANGLE = 2,
    OVAL = 3,
    POLYGON = 4     
};
 
 
struct PAD
{
    float    direction = 0.0f;
    uint8_t  shape = 0;
    int32_t  width = 0;       
    int32_t  height = 0;
    int32_t  clearance = 0;
    int32_t  drill = 0;       
    int32_t  reserved = 0;
    uint16_t number = 0;
};
 

struct TRIANGLE
{
    int32_t x2 = 0;
    int32_t y2 = 0;
    int32_t x3 = 0;
    int32_t y3 = 0;
};
 

struct RECTANGLE
{
    int32_t height = 0;
    int32_t width = 0;
    float   direction = 0.0f;
};
 

struct ARC
{
    int32_t endX = 0;
    int32_t endY = 0;
    int32_t centerX = 0;
    int32_t centerY = 0;
    int32_t radius = 0;
    int32_t width = 0;
    int32_t clearance = 0;
    float   startAngle = 0.0f;    
    float   endAngle = 0.0f;

    double Sweep() const
    {
        double sweep = std::fmod( double( endAngle ) - double( startAngle ), 360.0 );
        return sweep <= 0.0 ? sweep + 360.0 : sweep;
    }
};
 

struct DISC
{
    int32_t radius = 0;
};
 

enum class FIDUCIAL_KIND : uint8_t
{
    CROSSHAIR_RINGS = 0,     
    TRIANGLE_DIAMETER = 1,
    PAIRED_SECTORS = 2,
    FILLED_CIRCLE = 3        
};
 
 
struct FIDUCIAL
{
    uint8_t kind = 0;        
    int32_t radius = 0;
    int32_t width = 0;
    float   direction = 0.0f;
};
 

struct SPLINE
{
    int32_t endX = 0;
    int32_t endY = 0;
    int32_t controlX = 0;
    int32_t controlY = 0;
    int32_t width = 0;
    int32_t clearance = 0;
};
 
 
enum class TEXT_FUNCTION : uint8_t
{
    LITERAL = 0,
    REFERENCE = 1,
    VALUE = 2,
    GATE_NAME = 3,
    SIGNAL_NAME = 4,
    PIN_NAME = 5,
    CHANGE_DATE = 11,
    CHANGE_TIME = 12,
    OUTPUT_DATE = 13,
    OUTPUT_TIME = 14,
    SCALE = 15,
    PROJECT_NAME = 16,
    SHEET_NUMBER = 100,
    FILE_NAME = 103,
    PAGE_NAME = 105
};
 
 
enum class TEXT_LANGUAGE : uint8_t
{
    GERMAN = 0,
    ENGLISH = 1,
    FRENCH = 2
};
 
 
struct TEXT
{
    std::string text;
    int32_t     height = 0;
    int32_t     width = 0;
    float       direction = 0.0f;
    uint8_t     weight = 0;
    uint8_t     noAutoUpright = 0;
    uint8_t     mirrored = 0;
    uint8_t     function = 0;
    std::string font;
};
 
 
struct DRC_MARKER
{
    int32_t     radius = 0;
    std::string text;
};
 
 
struct ELEMENT;
 

struct SYMBOL
{
    std::string          name;            
    std::string          suffix;          
    uint16_t             gateOrdinal = 0;
    uint8_t              insertRequired = 0;
    uint16_t             swapLevel = 0;
    std::vector<ELEMENT> children;
};
 

struct PACKAGE
{
    std::string package;
    std::string library;
    uint16_t    padCount = 0;
    uint8_t     bottomSide = 0;
    float       direction = 0.0f;
};
 
 
struct COMPONENT
{
    std::string          name;
    std::string          value;
    std::string          prefix;              
    std::string          library;
    std::string          package;
    std::string          packageSource;
    uint16_t             referenceNumber = 0;
    std::optional<uint16_t> referenceExtension;
    uint16_t             connectionCount = 0;
    uint8_t              gateState = 0;
    std::vector<ELEMENT> packageItems;
    std::vector<ELEMENT> symbols;
    uint8_t              setBitmap[5] = {};
};
 
 
struct SIGNAL
{
    std::string          name;
    std::vector<ELEMENT> connections;    
    std::vector<ELEMENT> tracks;         
    int32_t              minWidth = 0;
    int32_t              minSpacing = 0;
    std::string          string3;
    std::string          string4;
    std::vector<uint8_t> record;
    std::string          string5;
};
 

struct ELEMENT
{
    ELEMENT_TYPE type = ELEMENT_TYPE::NONE;
    ELEMENT_BASE base;
 
    LINE       line;
    PIN        pin;
    PAD        pad;
    TRIANGLE   triangle;
    RECTANGLE  rectangle;
    ARC        arc;
    DISC       disc;
    TEXT       text;
    FIDUCIAL   fiducial;
    SPLINE     spline;
    DRC_MARKER marker;
 
    // Larger aggregates are held indirectly to keep ELEMENT small.
    std::shared_ptr<SYMBOL>    symbol;
    std::shared_ptr<PACKAGE>   package;
    std::shared_ptr<COMPONENT> component;
    std::shared_ptr<SIGNAL>    signal;

    std::vector<ELEMENT> children;
};
 

constexpr int BOARD_LAYER_COUNT = 100;
 

constexpr int FIRST_PADSTACK_LAYER = 101;
 

struct PADSTACK_DEF
{
    std::string                            name;
    std::array<bool, BOARD_LAYER_COUNT>    onLayer{};
    std::array<int32_t, BOARD_LAYER_COUNT> oversize{};    
};
 

struct PROJECT_SETTINGS
{
    std::vector<std::string>  sheetNames;     
    std::string               savedBy;

    std::optional<TEXT_LANGUAGE> textLanguage;

    std::vector<std::pair<std::string, std::string>> properties;
    std::vector<PADSTACK_DEF> padstacks;
};
 

enum class LAYER_FUNCTION : uint8_t
{
    COPPER_BOTTOM = 0,
    COPPER_INSIDE = 1,
    COPPER_TOP = 2,
    POSITION_BOTTOM = 3,
    POSITION_TOP = 4,
    DELETION_BOTTOM = 5,
    DELETION_INSIDE = 6,
    DELETION_TOP = 7,
    AREA_BOTTOM = 8,
    AREA_INSIDE = 9,
    AREA_TOP = 10,
    MASK_BOTTOM = 11,
    MASK_TOP = 12,
    DRILL_PLAN = 13,
    PASTE_BOTTOM = 14,
    PASTE_TOP = 15,
    GOLD_BOTTOM = 16,
    GOLD_TOP = 17,
    GLUE_BOTTOM = 18,
    GLUE_TOP = 19,
    DIMENSIONING = 20,
    OUTLINE = 21,
    MILLING = 22,
    PAD_NUMBERS = 23,
    OTHER = 24,
    AIR_WIRES = 25,
    NAMES_TOP = 41,
    VALUES_TOP = 42,
    NAMES_BOTTOM = 43,
    VALUES_BOTTOM = 44
};

constexpr uint8_t NO_ASSOCIATION = 255;
 
 
struct PROJECT
{
    int32_t     version = 0;

    std::array<uint8_t, BOARD_LAYER_COUNT> layerFunctions{};

    std::array<uint8_t, BOARD_LAYER_COUNT> layerAssociations{};
 
    std::string schematicTextFont;
    std::string boardTextFont;
    std::string signalNameFont;
 
    std::vector<ELEMENT> signals;
    std::vector<ELEMENT> components;
    std::vector<ELEMENT> schematicItems;
    std::vector<ELEMENT> boardItems;
 
    PROJECT_SETTINGS settings;
 
    wxString   fileName;        
    wxDateTime fileModified;    

    const std::string* FindProperty( const std::string& aKey ) const;

    std::optional<wxString> FunctionText( const TEXT& aText, bool aSchematic ) const;

    const ELEMENT* FindSignal( uint16_t aId ) const;

    void ApplyTextLanguage();
};
 

PROJECT ParseFile( const wxString& aFileName );

PROJECT ParseBuffer( const std::vector<uint8_t>& aData );

bool LooksLikeProject( const wxString& aFileName );

wxString ToWx( const std::string& aRaw );
 

wxString PadNumber( const ELEMENT& aPad );
 
} // namespace TARGET3001
 
#endif // TARGET3001_PARSER_H