allegro_pcb_structs.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright Quilter
 * 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 3
 * 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/gpl-3.0.html
 * or you may search the http://www.gnu.org website for the version 3 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_any_map.h"
 
 
#include <array>
#include <concepts>
#include <cstdint>
#include <optional>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
 
namespace ALLEGRO
{

class BLOCK_BASE
{
public:
    BLOCK_BASE( uint8_t aBlockType, size_t aOffset ) :
            m_blockType( aBlockType ),
            m_offset( aOffset ),
            m_Key( 0 ), // Key and next are set later, during parse
            m_Next( 0 )
    {
    }
 
    virtual ~BLOCK_BASE() = default;

    uint8_t GetBlockType() const { return m_blockType; }
    size_t  GetOffset() const { return m_offset; }
 
    // Unique object identifier for this block, or 0 if it has none.
    uint32_t GetKey() const { return m_Key; }
    // Object key of the next block in this block's primary linked-list, or 0.
    uint32_t GetNext() const { return m_Next; }
 
    void SetKey( uint32_t aKey ) { m_Key = aKey; }
    void SetNext( uint32_t aNext ) { m_Next = aNext; }
 
private:
    uint8_t  m_blockType;
    size_t   m_offset;
    uint32_t m_Key;
    uint32_t m_Next;
};
 

template <typename T>
concept HAS_BLOCK_TYPE_CODE = requires
{
    T::BLOCK_TYPE_CODE;
};
 
 
template <typename T>
class BLOCK : public BLOCK_BASE
{
public:
    explicit BLOCK( size_t aOffset ) requires HAS_BLOCK_TYPE_CODE<T>
        : BLOCK_BASE( T::BLOCK_TYPE_CODE, aOffset )
    {
    }

    BLOCK( uint8_t aBlockType, size_t aOffset ) :
            BLOCK_BASE( aBlockType, aOffset )
    {
    }
 
    const T& GetData() const { return m_data; }
    T&       GetData() { return m_data; }
 
private:
    T m_data;
};
 

enum class FMT_VER
{
    V_UNKNOWN,
    V_PRE_V16, // Allegro versions before 16.0 (unsupported binary format)
    V_160, // Allegro 16.0, 0x00130000
    V_162, // Allegro 16.2  0x00130400
    V_164, // Allegro 16.4, 0x00130C00
    V_165, // Allegro 16.5, 0x00131000
    V_166, // Allegro 16.6, 0x00131500
    V_172, // Allegro 17.2, 0x00140400
    V_174, // Allegro 17.4, 0x00140900
    V_175, // Allegro 17.5, 0x00141500
    V_180, // Allegro 18.0, 0x00150000
};
 
constexpr bool operator>=( FMT_VER lhs, FMT_VER rhs )
{
    return static_cast<uint32_t>( lhs ) >= static_cast<uint32_t>( rhs );
}
 

template <typename P>
concept FMT_VER_PREDICATE = requires( P p, FMT_VER v )
{
    { p( v ) }->std::convertible_to<bool>;
};
 

template <FMT_VER_PREDICATE auto Pred, typename T>
struct COND_FIELD
{
    using value_type = T;
 
    static constexpr bool exists( FMT_VER aVer ) { return Pred( aVer ); }
 
    // Access to the value (use std::optional-like semantics)
    T&       value() { return *m_Value; }
    const T& value() const { return *m_Value; }
    bool     has_value() const { return m_Value.has_value(); }
 
    const T& value_or( const T& aDefault ) const { return has_value() ? value() : aDefault; }
 
    T&       operator*() { return *m_Value; }
    const T& operator*() const { return *m_Value; }
 
    T*       operator->() { return &m_Value.value(); }
    const T* operator->() const { return &*m_Value; }
 
    // Assignment operator
    COND_FIELD& operator=( const T& aValue )
    {
        m_Value = aValue;
        return *this;
    }
 
    COND_FIELD& operator=( T&& aValue )
    {
        m_Value = std::move( aValue );
        return *this;
    }
 
private:
    std::optional<T> m_Value;
};
 
 
// Predicate functors
 
template <FMT_VER Min>
struct VER_GE
{
    constexpr bool operator()( FMT_VER v ) const { return v >= Min; }
};
 
template <FMT_VER Max>
struct VER_LT
{
    constexpr bool operator()( FMT_VER v ) const { return v < Max; }
};
 
template <FMT_VER Min, FMT_VER Max>
struct VER_GE_LT
{
    constexpr bool operator()( FMT_VER v ) const { return v >= Min && v < Max; }
};
 
 
// Useful aliases for common cases

template <FMT_VER Min, typename T>
using COND_GE = COND_FIELD<VER_GE<Min>{}, T>;

template <FMT_VER Max, typename T>
using COND_LT = COND_FIELD<VER_LT<Max>{}, T>;

template <FMT_VER Min, FMT_VER Max, typename T>
using COND_GE_LT = COND_FIELD<VER_GE_LT<Min, Max>{}, T>;

template <typename T>
concept VERSIONED_COND_FIELD = requires( FMT_VER v )
{
    { T::exists( v ) }->std::convertible_to<bool>;
    typename T::value_type;
};
 
 
enum BOARD_UNITS
{
    MILS = 0x01,
    INCHES = 0x02,
    MILLIMETERS = 0x03,
    CENTIMETERS = 0x04,
    MICROMETERS = 0x05,
};
 

struct FILE_HEADER
{
    struct LAYER_MAP_ENTRY
    {
        uint32_t m_A;
        uint32_t m_LayerList0x2A;
    };

    struct LINKED_LIST
    {
        uint32_t m_Tail;
        uint32_t m_Head;
    };
 
    uint32_t                m_Magic;
 
    uint32_t                m_Unknown1a;        // 0x03
    uint32_t                m_FileRole;         // 0x01 (.brd) or 0x02 (.dra) (?)
    uint32_t                m_Unknown1b;        // 0x03
    uint32_t                m_WriterProgram;    // 0x09 (Allegro) or 0x130000 (DB Doctor) (?)
 
    uint32_t                m_ObjectCount;
 
    uint32_t                m_UnknownMagic;     // This is always 0x000a0d0a?
    uint32_t                m_UnknownFlags;     // This looks like flags: 0x01000000, 0x0400000, 0x06000000
 
    // In this block of 7 uint32s, it seems they have very different meanings pre and post v18
 
    // Pre v18, these are all unknown
    // - 3 and 4 are the same.
    // - 5 and 6 arer of a similar size
    COND_LT<FMT_VER::V_180, std::array<uint32_t, 7>> m_Unknown2_preV18;
 
    // V18
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2a_V18;          // Looks like an 'end pointer' like 0x27_end
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2b_V18;          // 0x00
    COND_GE<FMT_VER::V_180, uint32_t> m_0x27_End_V18;
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2d_V18;          // 0x00
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2e_V18;          // 25? (perhaps layer count?)
    COND_GE<FMT_VER::V_180, uint32_t> m_StringCount_V18;
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2g_V18;          // 0x00
 
    // V180 has 6 additional linked lists in the header
    // 5 of them are at the start
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_1;
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_2;
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_3;
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_4;
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_5;
 
    // Linked lists grouping top-level elements by type
    LINKED_LIST m_LL_0x04;              // Net assignments
    LINKED_LIST m_LL_0x06;              // Component definitions
    LINKED_LIST m_LL_0x0C;              // Pin definitions
    LINKED_LIST m_LL_Shapes;            // Shape segments (0x0E) and shapes (0x28)
    LINKED_LIST m_LL_0x14;              // Graphics
    LINKED_LIST m_LL_0x1B_Nets;         // Nets
    LINKED_LIST m_LL_0x1C;              // Padstacks
    LINKED_LIST m_LL_0x24_0x28;         // Rects and shapes
    LINKED_LIST m_LL_Unknown1;
    LINKED_LIST m_LL_0x2B;              // Footprint definitions
    LINKED_LIST m_LL_0x03_0x30;         // Fields (0x03) and string wrappers (0x30)
    LINKED_LIST m_LL_0x0A;              // DRC elements
    LINKED_LIST m_LL_0x1D_0x1E_0x1F;    // Constraint sets, SI models, padstack dims
    LINKED_LIST m_LL_Unknown2;
    LINKED_LIST m_LL_0x38;              // Films
    LINKED_LIST m_LL_0x2C;              // Tables
    LINKED_LIST m_LL_0x0C_2;            // Secondary pin definitions
    LINKED_LIST m_LL_Unknown3;
 
    // For some reason the 0x35 extents are recorded in the header
    COND_LT<FMT_VER::V_180, uint32_t> m_0x35_Start_preV18;
    COND_LT<FMT_VER::V_180, uint32_t> m_0x35_End_preV18;
 
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_Unknown5_V18;
    LINKED_LIST m_LL_0x36;
    COND_LT<FMT_VER::V_180, LINKED_LIST> m_LL_Unknown5_preV18;
 
    LINKED_LIST m_LL_Unknown6;
    LINKED_LIST m_LL_0x0A_2;
 
    COND_LT<FMT_VER::V_180, uint32_t> m_Unknown3;
 
    COND_GE<FMT_VER::V_180, LINKED_LIST> m_LL_V18_6;
 
    COND_GE<FMT_VER::V_180, uint32_t> m_0x35_Start_V18;
    COND_GE<FMT_VER::V_180, uint32_t> m_0x35_End_V18;
 
    // Fixed length string field
    std::array<char, 60> m_AllegroVersion;
 
    uint32_t m_Unknown4;
 
    uint32_t m_MaxKey;
 
    COND_LT<FMT_VER::V_180, std::array<uint32_t, 17>> m_Unknown5_preV18;
    COND_GE<FMT_VER::V_180, std::array<uint32_t, 9>>  m_Unknown5_V18;
 
    BOARD_UNITS m_BoardUnits;
    // 3 empty bytes here?
 
    uint32_t m_Unknown6;
    COND_LT<FMT_VER::V_180, uint32_t> m_Unknown7;
 
    // The end of the 0x27 object(?)
    // In V18, this is relocated to m_0x27_End_V18
    COND_LT<FMT_VER::V_180, uint32_t> m_0x27_End_preV18;
 
    uint32_t m_Unknown8;
 
    COND_LT<FMT_VER::V_180, uint32_t> m_StringCount_preV18;
 
    std::array<uint32_t, 50> m_Unknown9;
 
    uint32_t m_Unknown10a;  // Often 0x000500FF
    uint32_t m_Unknown10b;  // Similar to 0xFFA60000
    uint32_t m_Unknown10c;  // Usually 0x01
 
    // E.g. 1000 for mils
    uint32_t m_UnitsDivisor;

    std::array<LAYER_MAP_ENTRY, 25> m_LayerMap;
 
    uint32_t GetStringsCount() const
    {
        if( m_StringCount_V18.has_value() )
            return m_StringCount_V18.value();
 
        return m_StringCount_preV18.value();
    }
 
    uint32_t Get_0x27_End() const
    {
        if( m_0x27_End_V18.has_value() )
            return m_0x27_End_V18.value();
 
        return m_0x27_End_preV18.value();
    }
 
    const LINKED_LIST& GetUnknown5() const
    {
        if( m_LL_Unknown5_V18.has_value() )
            return m_LL_Unknown5_V18.value();
 
        return m_LL_Unknown5_preV18.value();
    }
};
 
 
struct LAYER_INFO
{
    enum CLASS
    {
        BOARD_GEOMETRY       = 0x01,
        COMPONENT_VALUE      = 0x02,
        DEVICE_TYPE          = 0x03,
        DRAWING_FORMAT       = 0x04,
        DRC_ERROR            = 0x05,
        ETCH                 = 0x06,
        MANUFACTURING        = 0x07,
        ANALYSIS             = 0x08,
        PACKAGE_GEOMETRY     = 0x09,
        PACKAGE_KEEPIN       = 0x0A,
        PACKAGE_KEEPOUT      = 0x0B,
        PIN                  = 0x0C,
        REF_DES              = 0x0d,
        ROUTE_KEEPIN         = 0x0e,
        ROUTE_KEEPOUT        = 0x0f,
        TOLERANCE            = 0x10,
        USER_PART_NUMBER     = 0x11,
        VIA_CLASS            = 0x12,
        VIA_KEEPOUT          = 0x13,
        ANTI_ETCH            = 0x14,
        BOUNDARY             = 0x15,
        CONSTRAINTS_REGION   = 0x16,
    };

    enum SUBCLASS
    {
        // BOARD_GEOMETRY
        // BGEOM_PASTEMASK_BOTTOM     = 0x??
        // BGEOM_PASTEMASK_TOP        = 0x??
        BGEOM_OUTLINE                 = 0xEA,
        BGEOM_CONSTRAINT_AREA         = 0xEB,
        BGEOM_OFF_GRID_AREA           = 0xEC,
        BGEOM_SOLDERMASK_BOTTOM       = 0xED,
        BGEOM_SOLDERMASK_TOP          = 0xEE,
        BGEOM_ASSEMBLY_DETAIL         = 0xEF,
        BGEOM_SILKSCREEN_BOTTOM       = 0xF0,
        BGEOM_SILKSCREEN_TOP          = 0xF1,
        BGEOM_SWITCH_AREA_BOTTOM      = 0xF2,
        BGEOM_SWITCH_AREA_TOP         = 0xF3,
        BGEOM_BOTH_ROOMS              = 0xF4,
        BGEOM_BOTTOM_ROOM             = 0xF5,
        BGEOM_TOP_ROOM                = 0xF6,
        BGEOM_PLACE_GRID_BOTTOM       = 0xF7,
        BGEOM_PLACE_GRID_TOP          = 0xF8,
        BGEOM_DIMENSION               = 0xF9,
        BGEOM_TOOLING_CORNERS         = 0xFA,
        BGEOM_ASSEMBLY_NOTES          = 0xFB,
        BGEOM_PLATING_BAR             = 0xFC,
        BGEOM_DESIGN_OUTLINE          = 0xFD,
 
        // COMPONENT_VALUE / DEVICE_TYPE / USER_PART_NUMBER
        // REF_DES / TOLERANCE
        DISPLAY_BOTTOM               = 0xF8,
        DISPLAY_TOP                  = 0xF9,
        SILKSCREEN_BOTTOM            = 0xFA,
        SILKSCREEN_TOP               = 0xFB,
        ASSEMBLY_BOTTOM              = 0xFC,
        ASSEMBLY_TOP                 = 0xFD,
 
        // ANALYSIS
        ANALYSIS_PCB_TEMPERATURE     = 0xF8,
        ANALYSIS_HIGH_ISOCONTOUR     = 0xF9,
        ANALYSIS_MEDIUM3_ISOCONTOUR  = 0xFA,
        ANALYSIS_MEDIUM2_ISOCONTOUR  = 0xFB,
        ANALYSIS_MEDIUM1_ISOCONTOUR  = 0xFC,
        ANALYSIS_LOW_ISOCONTOUR      = 0xFD,
 
        // DRAWING_FORMAT
        DFMT_REVISION_DATA           = 0xF9,
        DFMT_REVISION_BLOCK          = 0xFA,
        DFMT_TITLE_DATA              = 0xFB,
        DFMT_TITLE_BLOCK             = 0xFC,
        DFMT_OUTLINE                 = 0xFD,
 
        // PACKAGE_GEOMETRY
        PGEOM_PASTEMASK_BOTTOM       = 0xEC,
        PGEOM_PASTEMASK_TOP          = 0xED,
        PGEOM_DFA_BOUND_BOTTOM       = 0xEE,
        PGEOM_DFA_BOUND_TOP          = 0xEF,
        PGEOM_DISPLAY_BOTTOM         = 0xF1,
        PGEOM_DISPLAY_TOP            = 0xF2,
        PGEOM_SOLDERMASK_BOTTOM      = 0xF3,
        PGEOM_SOLDERMASK_TOP         = 0xF4,
        PGEOM_BODY_CENTER            = 0xF5,
        PGEOM_SILKSCREEN_BOTTOM      = 0xF6,
        PGEOM_SILKSCREEN_TOP         = 0xF7,
        PGEOM_PAD_STACK_NAME         = 0xF8,
        PGEOM_PIN_NUMBER             = 0xF9,
        PGEOM_PLACE_BOUND_BOTTOM     = 0xFA,
        PGEOM_PLACE_BOUND_TOP        = 0xFB,
        PGEOM_ASSEMBLY_BOTTOM        = 0xFC,
        PGEOM_ASSEMBLY_TOP           = 0xFD,
 
        // MANUFACTURING
        MFR_XSECTION_CHART           = 0xF0,
        MFR_NO_PROBE_BOTTOM          = 0xF1,
        MFR_NO_PROBE_TOP             = 0xF2,
        MFR_AUTOSILK_BOTTOM          = 0xF3,
        MFR_AUTOSILK_TOP             = 0xF4,
        MFR_PROBE_BOTTOM             = 0xF5,
        MFR_PROBE_TOP                = 0xF6,
        MFR_NCDRILL_FIGURE           = 0xF7,
        MFR_NCDRILL_LEGEND           = 0xF8,
        MFR_NO_GLOSS_INTERNAL        = 0xF9,
        MFR_NO_GLOSS_BOTTOM          = 0xFA,
        MFR_NO_GLOSS_TOP             = 0xFB,
        MFR_NO_GLOSS_ALL             = 0xFC,
        MFR_PHOTOPLOT_OUTLINE        = 0xFD,
 
        // CONSTRAINTS_REGION
        CREG_ALL                     = 0xFD,
 
        // PACKAGE_KEEPIN / ROUTE_KEEPIN
        KEEPIN_ALL                   = 0xFD,
 
        // PACKAGE_KEEPOUT / ROUTE_KEEPOUT / VIA_KEEPOUT
        KEEPOUT_BOTTOM               = 0xFB,
        KEEPOUT_TOP                  = 0xFC,
        KEEPOUT_ALL                  = 0xFD,
    };
 
    uint8_t m_Class;
    uint8_t m_Subclass;
 
    bool operator==( const LAYER_INFO& ) const = default;
};
 

struct BLK_0x01_ARC
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x01;
 
    uint8_t  m_UnknownByte;
    uint8_t  m_SubType;     
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_Parent;
    uint32_t m_Unknown1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown6;
 
    uint32_t m_Width;
 
    int32_t m_StartX;
    int32_t m_StartY;
    int32_t m_EndX;
    int32_t m_EndY;
 
    double m_CenterX; // Center
    double m_CenterY;
    double m_Radius;
 
    std::array<int32_t, 4> m_BoundingBoxCoords;
};
 

struct BLK_0x03_FIELD
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x03;
 
    struct SUB_0x6C
    {
        uint32_t              m_NumEntries;
        std::vector<uint32_t> m_Entries;
    };
 
    struct SUB_0x70_0x74
    {
        uint16_t              m_X0;
        uint16_t              m_X1;
        std::vector<uint32_t> m_Entries;
    };
 
    struct SUB_0xF6
    {
        std::array<uint32_t, 20> m_Entries;
    };
 
    uint16_t m_Hdr1;
 
    uint32_t m_Key;
    uint32_t m_Next;
 
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint8_t  m_SubType;
    uint8_t  m_Hdr2;
    uint16_t m_Size;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    std::variant<uint32_t, std::array<uint32_t, 2>, std::string, SUB_0x6C, SUB_0x70_0x74, SUB_0xF6> m_Substruct;
};

enum FIELD_KEYS
{
    LOGICAL_PATH = 0x37,
    MIN_LINE_WIDTH = 0x55,
    NET_SCHEDULE = 0x77,          
    MAX_LINE_WIDTH = 0x173,
    MIN_NECK_WIDTH = 0x5c,
    MAX_NECK_LENGTH = 0x1fb,
    PHYS_CONSTRAINT_SET = 0x1a0,  
};
 

struct BLK_0x04_NET_ASSIGNMENT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x04;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_Net;
    uint32_t m_ConnItem;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown;
};
 

struct BLK_0x05_TRACK
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x05;
 
    LAYER_INFO m_Layer;
 
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_NetAssignment;
    uint32_t m_UnknownPtr1;
    uint32_t m_Unknown2;
    uint32_t m_Unknown3;
    uint32_t m_UnknownPtr2a;
    uint32_t m_UnknownPtr2b;
    uint32_t m_Unknown4;
    uint32_t m_UnknownPtr3a;
    uint32_t m_UnknownPtr3b;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown5a;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown5b;
 
    uint32_t m_FirstSegPtr;
    uint32_t m_UnknownPtr5;
    uint32_t m_Unknown6;
};
 

struct BLK_0x06_COMPONENT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x06;
 
    uint32_t m_Key;
 
    // Pointer to the next BLK_0x06_COMPONENT
    uint32_t m_Next;
    // Pointer to COMP_DEVICE_TYPE string
    uint32_t m_CompDeviceType;
    // Pointer to SYM_NAME string
    uint32_t m_SymbolName;
    // Points to 0x07, first instance
    uint32_t m_FirstInstPtr;
    // Points to 0x0F, function slot
    uint32_t m_PtrFunctionSlot;
    // Points to 0x08, pin number
    uint32_t m_PtrPinNumber;
 
    // Points to 0x03, first 'field'
    uint32_t m_Fields;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
};
 

struct BLK_0x07_COMPONENT_INST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x07;
 
    uint32_t m_Key;
 
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_UnknownPtr1;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    uint32_t m_FpInstPtr;
 
    COND_LT<FMT_VER::V_172, uint32_t> m_Unknown4;
 
    uint32_t m_RefDesStrPtr;
    uint32_t m_FunctionInstPtr;
    uint32_t m_X03Ptr; // 0x03 or null
    uint32_t m_Unknown5;
    uint32_t m_FirstPadPtr; // 0x32 or null
};
 

struct BLK_0x08_PIN_NUMBER
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x08;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Key;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Previous;
    COND_LT<FMT_VER::V_172, uint32_t> m_StrPtr16x;
 
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_StrPtr;

    uint32_t m_PinNamePtr;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_Ptr4;
 
    uint32_t GetStrPtr() const
    {
        return m_StrPtr.value_or( m_StrPtr16x.value_or( 0 ) );
    }
};
 

struct BLK_0x09_FILL_LINK
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x09;
 
    uint32_t m_Key;
 
    std::array<uint32_t, 4> m_UnknownArray;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_UnknownPtr1;
    uint32_t m_UnknownPtr2;
    uint32_t m_Unknown2;
    uint32_t m_UnknownPtr3;
    uint32_t m_UnknownPtr4;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
};
 

struct BLK_0x0A_DRC
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x0A;
 
    uint8_t    m_T;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Unknown1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    std::array<int32_t, 4>  m_Coords;
    std::array<uint32_t, 4> m_Unknown4;
    std::array<uint32_t, 5> m_Unknown5;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown6;
};
 

struct BLK_0x0C_PIN_DEF
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x0C;
 
    enum MARKER_SHAPE
    {
        // These are in the same order as the pad shapes, at least for the 'simple' shapes
        CIRCLE = 0x02,
        OCTAGON = 0x03,
        CROSS = 0x04,
        SQUARE = 0x05,
        RECTANGLE = 0x06,
        DIAMOND = 0x07,
        PENTAGON = 0x0a,
        OBLONG_X = 0x0b,
        OBLONG_Y = 0x0c,
        HEXAGON_X = 0x0f,
        HEXAGON_Y = 0x10,
        TRIANGLE = 0x12,
    };
 
    uint8_t    m_T;
    LAYER_INFO m_Layer;
    uint32_t m_Key;
    uint32_t m_Next;
 
    uint32_t m_Unknown1;
    uint32_t m_Unknown2;
 
    COND_LT<FMT_VER::V_172, uint8_t>  m_Shape;
    COND_LT<FMT_VER::V_172, uint8_t>  m_DrillChar;
    COND_LT<FMT_VER::V_172, uint16_t> m_UnknownPadding; // or drill char?
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Shape16x;
    COND_GE<FMT_VER::V_172, uint32_t> m_DrillChars;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown_16x;
 
    uint32_t m_Unknown4;
 
    COND_GE<FMT_VER::V_180, uint32_t> m_Unknown5;
 
    std::array<int32_t, 2> m_Coords;
    std::array<int32_t, 2> m_Size;
 
    uint32_t m_GroupPtr;
    uint32_t m_Unknown6;
    uint32_t m_Unknown7;
 
    COND_GE_LT<FMT_VER::V_174, FMT_VER::V_180, uint32_t> m_Unknown8;
 
    uint32_t GetShape() const
    {
        return m_Shape16x.value_or( m_Shape.value_or( 0 ) );
    }
};
 

struct BLK_0x0D_PAD
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x0D;
 
    uint32_t m_Key;
    uint32_t m_NameStrId;
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown1;
 
    int32_t m_CoordsX;  
    int32_t m_CoordsY;  
 
    uint32_t m_PadStack;
    uint32_t m_Unknown2;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    uint32_t m_Flags;
    uint32_t m_Rotation;  
};
 

struct BLK_0x0E_RECT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x0E;
 
    uint8_t  m_T;
    LAYER_INFO m_Layer;
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_FpPtr;
 
    uint32_t m_Unknown1;
    uint32_t m_Unknown2;
    uint32_t m_Unknown3;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown4;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown5;
 
    std::array<int32_t, 4> m_Coords;
 
    std::array<uint32_t, 3> m_UnknownArr;
    uint32_t m_Rotation;
};
 

struct BLK_0x0F_FUNCTION_SLOT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x0F;
 
    uint32_t m_Key;
 
    uint32_t m_SlotName;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown1;
 
    std::array<char, 32> m_CompDeviceType;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Next;
 
    uint32_t m_Ptr0x06;
    uint32_t m_Ptr0x11;
 
    uint32_t m_Unknown2;
 
    std::string GetCompDeviceTypeStr() const
    {
        // The string is stored as a fixed-length array, but is null-terminated
        return std::string( m_CompDeviceType.data(), strnlen( m_CompDeviceType.data(), m_CompDeviceType.size() ) );
    }
};
 

struct BLK_0x10_FUNCTION_INST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x10;
 
    uint32_t m_Key;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_ComponentInstPtr;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown2;
 
    uint32_t m_PtrX12;
    uint32_t m_Unknown3;
    uint32_t m_FunctionName;
    uint32_t m_Slots; // 0x0F?
    uint32_t m_Fields;     // Presumably a pointer to a string
};
 

struct BLK_0x11_PIN_NAME
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x11;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Key;
    uint32_t m_PinNameStrPtr;
    uint32_t m_Next;
    uint32_t m_PinNumberPtr;
    uint32_t m_Unknown1;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown2;
};
 

struct BLK_0x12_XREF
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x12;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Key;
    uint32_t m_Ptr1;
    uint32_t m_Ptr2;
    uint32_t m_Ptr3;
    uint32_t m_Unknown1;
 
    COND_GE<FMT_VER::V_165, uint32_t> m_Unknown2;
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
};
 

struct BLK_0x14_GRAPHIC
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x14;
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Parent;
    uint32_t   m_Flags;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    uint32_t m_SegmentPtr;
    uint32_t m_Ptr0x03;
    uint32_t m_Ptr0x26;
};
 

struct BLK_0x15_16_17_SEGMENT
{
    // Segments can be one of 3 codes, so we don't have a BLOCK_TYPE_CODE constant
    // for this struct.
 
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_Parent;
    uint32_t m_Flags;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    uint32_t m_Width;
 
    int32_t m_StartX;
    int32_t m_StartY;
    int32_t m_EndX;
    int32_t m_EndY;
};

struct BLK_0x1B_NET
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x1B;
 
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_NetName;
 
    uint32_t m_Unknown1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    uint32_t m_Type;
 
    uint32_t m_Assignment;
    uint32_t m_Ratline;
    uint32_t m_FieldsPtr;
    uint32_t m_MatchGroupPtr; 
    uint32_t m_ModelPtr;
    uint32_t m_UnknownPtr4;
    uint32_t m_UnknownPtr5;
    uint32_t m_UnknownPtr6;
};
 

enum class PAD_TYPE
{
    THROUGH_VIA,
    VIA,
    SMD_PIN,
    SLOT,
    NPTH,
};
 

struct PADSTACK_COMPONENT
{
    enum TYPE
    {
        TYPE_NULL = 0x00,
        TYPE_CIRCLE = 0x02,
        TYPE_OCTAGON = 0x03,
        TYPE_CROSS = 0x04,
        TYPE_SQUARE = 0x05,
        TYPE_RECTANGLE = 0x06,
        TYPE_DIAMOND = 0x07,
        TYPE_PENTAGON = 0x0a,
        TYPE_OBLONG_X = 0x0b,
        TYPE_OBLONG_Y = 0x0c,
        TYPE_HEXAGON_X = 0x0f,
        TYPE_HEXAGON_Y = 0x10,
        TYPE_TRIANGLE = 0x12,
        TYPE_SHAPE_SYMBOL = 0x16,
        TYPE_FLASH = 0x17,
        TYPE_DONUT = 0x19,
        TYPE_ROUNDED_RECTANGLE = 0x1b,
        TYPE_CHAMFERED_RECTANGLE = 0x1c,
        TYPE_NSIDED_POLYGON = 0x1e,
        TYPE_APERTURE_EXT = 0xee,
    };
 
    uint8_t m_Type;
    uint8_t m_UnknownByte1;
    uint8_t m_UnknownByte2;
    uint8_t m_UnknownByte3;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    // Pad size
    int32_t m_W;
    int32_t m_H;
 
    // In rounded rectangles, this is the corner radius.
    // In chamfered rectangles, this is the chamfer size.
    COND_GE<FMT_VER::V_172, int32_t> m_Z1;
 
    // This is the pad component offset
    int32_t m_X3;
    int32_t m_X4;

    uint32_t m_StrPtr;
 
    // In versions < 17.2, seems to be not present in the last entry.
    std::optional<uint32_t> m_Z2;
};
 

struct BLK_0x1C_PADSTACK
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x1C;
 
    struct HEADER_v16x
    {
        enum PAD_FLAGS
        {
            FLAG_PLATED = 0x01,
            // NPTHs seem to have this instead of 0x01
            // SMDs seems to have this or 0x01, no clear pattern identified
            FLAG_UNKNOWN1 = 0x02,
        };
 
        uint32_t m_DrillSize;
        uint32_t m_UnknownStr;
        uint32_t m_DrillMarkSizeX;
        uint32_t m_DrillMarkSizeY;
        // Not sure these are in the right place but they're in here somewhere (usually zero)
        uint32_t m_DrillOffsetX;
        uint32_t m_DrillOffsetY;
 
        // Drill char presumably somewhere in here - can cross-match with 0x0C PIN_DEF to find
        uint8_t m_DrillMarkShape;
        // Mask or enum of pad flags, including plating
        uint8_t m_Flags;
        // An ASCII char, or 0x00
        uint8_t m_DrillChar;
        uint8_t m_D;
 
        // Probably some kind of type:
        // 0x0000 for through-hole
        // 0x0002 for SMD
        // 0x0400 for slots
        uint16_t m_Unknown_1;
 
        uint16_t m_ArrayNX;
        uint16_t m_ArrayNY;
 
        uint16_t m_LayerCount;
        // Also unsure if these are in the right place (all usually 0?)
        uint32_t m_ClearanceX;
        uint32_t m_ClearanceY;
 
        uint32_t m_TolerancePos;
        uint32_t m_ToleranceNeg;
        uint32_t m_Unknown_2;
        uint32_t m_SlotX;
        uint32_t m_SlotY;
        uint32_t m_Unknown_3;
 
        COND_GE<FMT_VER::V_165, uint32_t> m_Unknown_4;
    };
 
    struct HEADER_v17x
    {
        enum PAD_FLAGS
        {
            // Some through-holes have this, some don't
            FLAG_UNKNOWN1   = 0x01,
            FLAG_PLATED     = 0x20,
        };
 
        // Presumably the same as the one in the v16x header
        uint32_t m_UnknownStr;
        uint32_t m_Unknown1; // 0?
        uint32_t m_Unknown2; // 0?
 
        PAD_TYPE m_PadType;
 
        // Not sure if this is really a substruct
        uint8_t m_A; // Only lower 4 bits (top 4 are type)
        uint8_t m_B;
        uint8_t m_Flags;
        uint8_t m_D;
 
        uint32_t m_unknown3; // 1?
        uint32_t m_Unknown4; // 0?
 
        uint16_t m_ArrayNX;
        uint16_t m_ArrayNY;
        uint16_t m_LayerCount;
        uint16_t m_Unknown5; // 0?
 
        // Again, these are tentatively placed, they're always zero so far,
        // so it's hard to say where they go.
        // Assuming they follow the v16x layout and come after the layer count
        uint32_t m_ClearanceX;
        uint32_t m_ClearanceY;
        uint32_t m_Unknown6a;
        uint32_t m_Unknown6b;
 
        uint32_t m_DrillSize;
        uint32_t m_TolerancePos;
        uint32_t m_ToleranceNeg;
        uint32_t m_SlotX;
        uint32_t m_SlotY;
        uint32_t m_ToleranceTravelPos; // "TOLERANCE_TRAVEL" in BeagleBone_Black drill table
        uint32_t m_ToleranceTravelNeg;
 
        uint32_t m_DrillMarkSizeX;
        uint32_t m_DrillMarkSizeY;
        uint32_t m_DrillMarkShape;
        uint32_t m_DrillChars; // Presumably 4 drill chars
 
        // Probably holds secondary drill parameters and other new V17.2 features
        std::array<uint32_t, 21> m_UnknownArr3;
 
        // To check - this could be another component?
        COND_GE<FMT_VER::V_180, std::array<uint32_t, 8>> m_UnknownArr_v180;
    };
 
    uint8_t m_UnknownByte1;

    uint8_t  m_N;
    uint8_t  m_UnknownByte2;
    uint32_t m_Key;
    uint32_t m_Next;
 
    // The name of the padstack
    uint32_t m_PadStr;
 
    // The header fields are very different between v16x and v17.x+
    using HEADER = std::variant<HEADER_v16x, HEADER_v17x>;
    HEADER m_Header;

    enum SLOTS
    {
        // V<172 verified slots
        SOLDERMASK_TOP_V16X = 0,
        PASTEMASK_TOP_V16X  = 5,
        FILMMASK_TOP_V16X   = 7,
 
        // V>=172 verified slots
        SOLDERMASK_TOP_V17X = 14,
    };

    enum LAYER_COMP_SLOT
    {
        // First slot: Antipad
        ANTIPAD = 0,
        // Thermal relief shape
        THERMAL_RELIEF = 1,
        // Pad shape
        PAD = 2,
        // Unsure what this layer component slot is
        // But I suspect it's keepout, as that was added in V172.
        UNKNOWN_GE_V172 = 3,
    };

    std::vector<PADSTACK_COMPONENT> m_Components;

    size_t m_NumFixedCompEntries;
    size_t m_NumCompsPerLayer;

    std::vector<uint32_t> m_UnknownArrN;
 
 
    // Dispatch common properties to the header variant.
    // Each method uses a local Visitor struct so that adding a new HEADER alternative
    // produces a compile error rather than a silent runtime fallback.
    uint32_t GetDrillSize() const
    {
        struct Visitor
        {
            uint32_t operator()( const HEADER_v16x& h ) const { return h.m_DrillSize; }
            uint32_t operator()( const HEADER_v17x& h ) const { return h.m_DrillSize; }
        };
        return std::visit( Visitor{}, m_Header );
    }
 
    uint32_t GetLayerCount() const
    {
        struct Visitor
        {
            uint32_t operator()( const HEADER_v16x& h ) const { return h.m_LayerCount; }
            uint32_t operator()( const HEADER_v17x& h ) const { return h.m_LayerCount; }
        };
        return std::visit( Visitor{}, m_Header );
    }
 
    bool IsPlated() const
    {
        struct Visitor
        {
            bool operator()( const HEADER_v16x& h ) const
            {
                return ( h.m_Flags & HEADER_v16x::PAD_FLAGS::FLAG_PLATED ) != 0;
            }
            bool operator()( const HEADER_v17x& h ) const
            {
                return ( h.m_Flags & HEADER_v17x::PAD_FLAGS::FLAG_PLATED ) != 0;
            }
        };
        return std::visit( Visitor{}, m_Header );
    }
};
 

struct BLK_0x1D_CONSTRAINT_SET
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x1D;
 
    uint32_t m_Key;
    uint32_t m_Next;         
    uint32_t m_NameStrKey;   
    uint32_t m_FieldPtr;     
    uint16_t m_SizeA;
    uint16_t m_SizeB;

    std::vector<std::array<uint8_t, 56>> m_DataB;
    std::vector<std::array<uint8_t, 256>> m_DataA;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown4;
};
 

struct BLK_0x1E_SI_MODEL
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x1E;
 
    uint8_t  m_Type;
    uint16_t m_T2;
    uint32_t m_Key;
    uint32_t m_Next;         
 
    // Versioning seems unsure here
    // At least it is in Kinoma (V_164)
    COND_GE<FMT_VER::V_164, uint16_t> m_Unknown2;
    COND_GE<FMT_VER::V_164, uint16_t> m_Unknown3;
 
    uint32_t m_StrPtr;
    uint32_t m_Size;
 
    std::string m_String;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown4;
};
 

struct BLK_0x1F_PADSTACK_DIM
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x1F;
 
    uint32_t m_Key;
    uint32_t m_Next;         
    uint32_t m_Unknown2;
    uint32_t m_Unknown3;
    uint32_t m_Unknown4;
    uint16_t m_Unknown5;
    uint16_t m_Size;

    std::vector<uint8_t> m_Substruct;
};
 

struct BLK_0x20_UNKNOWN
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x20;
 
    uint8_t                 m_Type;
    uint16_t                m_R;
    uint32_t                m_Key;
    uint32_t                m_Next;
    std::array<uint32_t, 7> m_UnknownArray1;
 
    COND_GE<FMT_VER::V_174, std::array<uint32_t, 10>> m_UnknownArray2;
};

struct BLK_0x21_BLOB
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x21;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Size;
    uint32_t m_Key;

    std::vector<uint8_t> m_Data;
};
 

struct BLK_0x22_UNKNOWN
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x22;
 
    uint8_t  m_Type;
    uint16_t m_T2;
    uint32_t m_Key;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    std::array<uint32_t, 8> m_UnknownArray;
};
 

struct BLK_0x23_RATLINE
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x23;
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
 
    std::array<uint32_t, 2> m_Flags;
 
    uint32_t m_Ptr1;
    uint32_t m_Ptr2;
    uint32_t m_Ptr3;
 
    std::array<int32_t, 5> m_Coords;
 
    std::array<uint32_t, 4> m_Unknown1;
 
    COND_GE<FMT_VER::V_164, std::array<uint32_t, 4>> m_Unknown2;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
};
 

struct BLK_0x24_RECT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x24;
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Parent;
    uint32_t   m_Unknown1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    std::array<int32_t, 4> m_Coords;
 
    uint32_t m_Ptr2;
 
    uint32_t m_Unknown3;
    uint32_t m_Unknown4;
    uint32_t m_Rotation;
};
 

struct BLK_0x26_MATCH_GROUP
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x26;
 
    uint8_t  m_Type;
    uint16_t m_R;
    uint32_t m_Key;
    uint32_t m_MemberPtr;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_GroupPtr;
    uint32_t m_ConstPtr;  
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown2;
};
 

struct BLK_0x27_CSTRMGR_XREF
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x27;
 
    std::vector<uint32_t> m_Refs;
};
 

struct BLK_0x28_SHAPE
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x28;
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Ptr1;
    uint32_t   m_Unknown1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    uint32_t m_Ptr2;
    uint32_t m_Ptr3;
    uint32_t m_FirstKeepoutPtr;
    uint32_t m_FirstSegmentPtr;
    uint32_t m_Unknown4;
    uint32_t m_Unknown5;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_TablePtr;
 
    uint32_t m_Ptr6;
 
    COND_LT<FMT_VER::V_172, uint32_t> m_TablePtr_16x;
 
    std::array<int32_t, 4> m_Coords;
 
    uint32_t GetTablePtr() const
    {
        return m_TablePtr.value_or( m_TablePtr_16x.value_or( 0 ) );
    }
};
 

struct BLK_0x29_PIN
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x29;
 
    uint8_t  m_Type;
    uint16_t m_T;
    uint32_t m_Key;
 
    // Points to something in the header
    uint32_t m_Ptr1;
    uint32_t m_Ptr2;
 
    uint32_t m_Null; // Null value
 
    uint32_t m_Ptr3;
 
    int32_t m_Coord1;
    int32_t m_Coord2;
 
    uint32_t m_PtrPadstack;
 
    uint32_t m_Unknown1;
 
    // Pointer to a string, e.g., "2" in R0603
    uint32_t m_PtrX30;
 
    uint32_t m_Unknown2;
    uint32_t m_Unknown3;
    uint32_t m_Unknown4;
};
 

struct BLK_0x2A_LAYER_LIST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2A;
 
    struct NONREF_ENTRY
    {
        std::string m_Name;
    };
 
    struct REF_ENTRY
    {
        uint32_t mLayerNameId; // string ID
        uint32_t m_Properties;
        uint32_t m_Unknown;
    };
 
    uint16_t m_NumEntries;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown;
 
    COND_LT<FMT_VER::V_165, std::vector<NONREF_ENTRY>> m_NonRefEntries;
    COND_GE<FMT_VER::V_165, std::vector<REF_ENTRY>>    m_RefEntries;
 
    uint32_t m_Key;
};
 

struct BLK_0x2B_FOOTPRINT_DEF
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2B;
 
    uint32_t m_Key;
 
    uint32_t m_FpStrRef;
    uint32_t m_Unknown1;
 
    // Could these be signed?
    std::array<uint32_t, 4> m_Coords;
 
    uint32_t m_Next;
    uint32_t m_FirstInstPtr;
    uint32_t m_UnknownPtr3;
    uint32_t m_UnknownPtr4;
    uint32_t m_UnknownPtr5;
    uint32_t m_SymLibPathPtr;
    uint32_t m_UnknownPtr6;
    uint32_t m_UnknownPtr7;
    uint32_t m_UnknownPtr8;
 
    COND_GE<FMT_VER::V_164, uint32_t> m_Unknown2;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
};
 

struct BLK_0x2C_TABLE
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2C;

    enum SUBTYPE
    {
        SUBTYPE_UNKNOWN = 0,
 
        SUBTYPE_0x05 = 0x05,
 
        SUBTYPE_0x06 = 0x06,
        SUBTYPE_0x0c = 0x0c,
        SUBTYPE_0x15 = 0x15,
        SUBTYPE_0x16 = 0x16,
        SUBTYPE_0x20 = 0x20,
        SUBTYPE_0x23 = 0x23,

        SUBTYPE_0x102 = 0x102,
        SUBTYPE_0x103 = 0x103,
        SUBTYPE_0x107 = 0x107,

        SUBTYPE_GRAPHICAL_GROUP = 0x110,
    };
 
    uint8_t  m_Type;
    uint16_t m_SubType;
    uint32_t m_Key;
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    uint32_t m_StringPtr;
 
    COND_LT<FMT_VER::V_172, uint32_t> m_Unknown4;
 
    uint32_t m_Ptr1;
    uint32_t m_Ptr2;
    uint32_t m_Ptr3;
 
    uint32_t m_Flags;
};
 

struct BLK_0x2D_FOOTPRINT_INST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2D;
 
    uint8_t  m_UnknownByte1;
    uint8_t  m_Layer;         // 0 = top (F_Cu), 1 = bottom (B_Cu)
    uint8_t  m_UnknownByte2;
 
    uint32_t m_Key;
 
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    // Unsure what 16x means
    COND_LT<FMT_VER::V_172, uint32_t> m_InstRef16x;
 
    uint16_t m_Unknown2;
    uint16_t m_Unknown3;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown4;
 
    uint32_t m_Flags;
 
    uint32_t m_Rotation;  
    int32_t  m_CoordX;
    int32_t  m_CoordY;
 
    // Presumably equivalent to m_InstRef16x
    COND_GE<FMT_VER::V_172, uint32_t> m_InstRef;
 
    uint32_t m_GraphicPtr;
    uint32_t m_FirstPadPtr;
    uint32_t m_TextPtr;  // Points to 0x30
 
    uint32_t m_AssemblyPtr;
    uint32_t m_AreasPtr;
    uint32_t m_UnknownPtr1;
    uint32_t m_UnknownPtr2;
 
    uint32_t GetInstRef() const
    {
        return m_InstRef.value_or( m_InstRef16x.value_or( 0 ) );
    }
};
 

struct BLK_0x2E_CONNECTION
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2E;
 
    uint8_t  m_Type;
    uint16_t m_T2;
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_NetAssignment;
    uint32_t m_Unknown1;
    int32_t m_CoordX;
    int32_t m_CoordY;
    uint32_t m_Connection;
    uint32_t m_Unknown2;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
};
 

struct BLK_0x2F_UNKNOWN
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x2F;
 
    uint8_t  m_Type;
    uint16_t m_T2;
    uint32_t m_Key;
 
    std::array<uint32_t, 6> m_UnknownArray;
};
 

struct BLK_0x30_STR_WRAPPER
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x30;
 
    enum class TEXT_REVERSAL
    {
        STRAIGHT,
        REVERSED,
        UNKNOWN,
    };
 
    enum class TEXT_ALIGNMENT
    {
        LEFT,
        RIGHT,
        CENTER,
        UNKNOWN,
    };
 
    struct TEXT_PROPERTIES
    {
        uint8_t        m_Key;
        uint8_t        m_Flags;
        TEXT_ALIGNMENT m_Alignment;
        TEXT_REVERSAL  m_Reversal;
    };
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t>        m_Unknown1;
    COND_GE<FMT_VER::V_172, uint32_t>        m_Unknown2;
    COND_GE<FMT_VER::V_172, TEXT_PROPERTIES> m_Font;
    COND_GE<FMT_VER::V_172, uint32_t>        m_Ptr1;
    COND_GE<FMT_VER::V_174, uint32_t>        m_Unknown3;
 
    uint32_t m_StrGraphicPtr;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_PtrGroup_17x;
    COND_LT<FMT_VER::V_172, uint32_t> m_Unknown4;
 
    COND_LT<FMT_VER::V_172, TEXT_PROPERTIES> m_Font16x;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Ptr2;
 
    int32_t m_CoordsX;
    int32_t m_CoordsY;
 
    uint32_t m_Unknown5;
    uint32_t m_Rotation;  
 
    COND_LT<FMT_VER::V_172, uint32_t> m_PtrGroup_16x;
 
    uint32_t GetGroupPtr() const
    {
        return m_PtrGroup_17x.value_or( m_PtrGroup_16x.value_or( 0 ) );
    }
};
 

struct BLK_0x31_SGRAPHIC
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x31;
 
    enum class STRING_LAYER : uint16_t
    {
        BOT_TEXT,
        TOP_TEXT,
        BOT_PIN,
        TOP_PIN,
        TOP_PIN_LABEL,
        BOT_REFDES,
        TOP_REFDES,
        UNKNOWN,
    };
 
    uint8_t      m_T;
    STRING_LAYER m_Layer;
    uint32_t     m_Key;
    uint32_t     m_StrGraphicWrapperPtr;
 
    int32_t m_CoordsX;
    int32_t m_CoordsY;
 
    uint16_t m_Unknown;
    uint16_t m_Len;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Un2;
 
    std::string m_Value;
};
 

struct BLK_0x32_PLACED_PAD
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x32;
 
    uint8_t    m_Type;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_NetPtr;
    uint32_t   m_Flags;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Prev;
 
    uint32_t m_NextInFp;
    uint32_t m_ParentFp;
    uint32_t m_Track;
    uint32_t m_PadPtr;
    uint32_t m_Ptr6;
    uint32_t m_Ratline;
    uint32_t m_PtrPinNumber;
    uint32_t m_NextInCompInst;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown2;
 
    uint32_t m_NameText;
    uint32_t m_Ptr11;
 
    std::array<int32_t, 4> m_Coords;
};
 

struct BLK_0x33_VIA
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x33;
 
    LAYER_INFO m_LayerInfo;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_NetPtr;
    uint32_t   m_Unknown2;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    uint32_t m_UnknownPtr1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_UnknownPtr2;
 
    int32_t m_CoordsX;
    int32_t m_CoordsY;
 
    uint32_t m_Connection;
    uint32_t m_Padstack;
    uint32_t m_UnknownPtr5;
    uint32_t m_UnknownPtr6;
 
    uint32_t m_Unknown4;
    uint32_t m_Unknown5;
 
    std::array<int32_t, 4> m_BoundingBoxCoords;
};
 

struct BLK_0x34_KEEPOUT
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x34;
 
    uint8_t    m_T;
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Ptr1;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_Flags;
    uint32_t m_FirstSegmentPtr;
    uint32_t m_Ptr3;
    uint32_t m_Unknown2;
};
 

struct BLK_0x35_FILE_REF
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x35;
 
    uint8_t  m_T2;
    uint16_t m_T3;
 
    std::array<uint8_t, 120> m_Content;
};
 

struct BLK_0x36_DEF_TABLE
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x36;
 
    uint16_t m_Code;
    uint32_t m_Key;
    uint32_t m_Next;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown1;
 
    uint32_t m_NumItems;
    uint32_t m_Count;
    uint32_t m_LastIdx;
    uint32_t m_Unknown2;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
 
    struct X02
    {
        std::string              m_String;
        std::array<uint32_t, 14> m_Xs;
 
        COND_GE<FMT_VER::V_164, std::array<uint32_t, 3>> m_Ys;
        COND_GE<FMT_VER::V_172, std::array<uint32_t, 2>> m_Zs;
    };
 
    struct X03
    {
        COND_GE<FMT_VER::V_172, std::string> m_Str;
        COND_LT<FMT_VER::V_172, std::string> m_Str16x;
        COND_GE<FMT_VER::V_174, uint32_t>    m_Unknown1;
    };
 
    struct X05
    {
        std::array<uint8_t, 28> m_Unknown;
 
        // This is in Nvidia Jetson (17.4), not in EVK BaseBoard (17.2)
        COND_GE<FMT_VER::V_174, uint32_t> m_Unknown2;
    };
 
    struct X06
    {
        uint16_t m_N;
        uint8_t  m_R;
        uint8_t  m_S;
        uint32_t m_Unknown1;
 
        COND_LT<FMT_VER::V_172, std::array<uint32_t, 50>> m_Unknown2;
    };
 
    struct FontDef_X08
    {
        uint32_t m_A;
        uint32_t m_B;
        uint32_t m_CharHeight;
        uint32_t m_CharWidth;
 
        COND_GE<FMT_VER::V_174, uint32_t> m_Unknown2;
 
        uint32_t m_CharacterSpace;
        uint32_t m_LineSpace;
        uint32_t m_Unknown3;    // Always 0?
        uint32_t m_StrokeWidth; // Aka "photo width"
 
        COND_GE<FMT_VER::V_172, std::array<uint32_t, 8>> m_Ys;
    };
 
    struct X0B
    {
        std::array<uint8_t, 1016> m_Unknown;
    };
 
    struct X0C
    {
        std::array<uint8_t, 232> m_Unknown;
    };
 
    struct X0D
    {
        std::array<uint8_t, 200> m_Unknown;
    };
 
    struct X0F
    {
        uint32_t                m_Key;
        std::array<uint32_t, 3> m_Ptrs;
        uint32_t                m_Ptr2;
    };
 
    struct X10
    {
        std::array<uint8_t, 108> m_Unknown;
 
        // V18 has an extra uint32 "somewhere" in this block
        COND_GE<FMT_VER::V_180, uint32_t> m_Unknown2;
    };
 
    // So far only seen in a V175 file (Jetson)
    struct X12
    {
        // No point reading this before we can use it
        // std::array<uint8_t, 1052> m_Unknown;
    };
 
    using SubstructVariant = std::variant<X02, X03, X05, X06, FontDef_X08, X0B, X0C, X0D, X0F, X10, X12>;
 
    std::vector<SubstructVariant> m_Items;
};
 

struct BLK_0x37_PTR_ARRAY
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x37;
 
    uint8_t  m_T;
    uint16_t m_T2;
    uint32_t m_Key;
    uint32_t m_GroupPtr;
    uint32_t m_Next;
    uint32_t m_Capacity;
    uint32_t m_Count;
    uint32_t m_Unknown2;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
 
    std::array<uint32_t, 100> m_Ptrs;
};
 

struct BLK_0x38_FILM
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x38;
 
    uint32_t m_Key;
    uint32_t m_Next;
    uint32_t m_LayerList;
 
    COND_LT<FMT_VER::V_166, std::string> m_FilmName;
 
    COND_GE<FMT_VER::V_166, uint32_t> m_LayerNameStr;
    COND_GE<FMT_VER::V_166, uint32_t> m_Unknown2;
 
    std::array<uint32_t, 7> m_UnknownArray1;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown3;
};
 

struct BLK_0x39_FILM_LAYER_LIST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x39;
 
    uint32_t m_Key;
    uint32_t m_Parent;
    uint32_t m_Head;
 
    // Array of 22 uint16_t values
    std::array<uint16_t, 22> m_X;
};
 

struct BLK_0x3A_FILM_LIST_NODE
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x3A;
 
    LAYER_INFO m_Layer;
    uint32_t   m_Key;
    uint32_t   m_Next;
    uint32_t   m_Unknown;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown1;
};
 

struct BLK_0x3B_PROPERTY
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x3B;
 
    uint8_t  m_T;
    uint16_t m_SubType;
    uint32_t m_Len;
 
    std::string m_Name;
    std::string m_Type;
 
    uint32_t m_Unknown1;
    uint32_t m_Unknown2;
 
    COND_GE<FMT_VER::V_172, uint32_t> m_Unknown3;
 
    std::string m_Value;
};
 

struct BLK_0x3C_KEY_LIST
{
    static constexpr uint8_t BLOCK_TYPE_CODE = 0x3C;
 
    uint8_t  m_T;
    uint16_t m_T2;
    uint32_t m_Key;
 
    COND_GE<FMT_VER::V_174, uint32_t> m_Unknown;
 
    uint32_t              m_NumEntries;
    std::vector<uint32_t> m_Entries;
};
 

template <typename T>
concept ALLEGRO_BLOCK_DATA = requires
{
    { T::BLOCK_TYPE_CODE }->std::convertible_to<uint8_t>;
}
|| std::is_same_v<T, BLK_0x15_16_17_SEGMENT>;
 
 
} // namespace ALLEGRO