20#include <boost/test/unit_test.hpp>
43#include <wx/filename.h>
50static std::vector<uint8_t> loadMinimalV13()
54 return { std::istreambuf_iterator<char>( file ), std::istreambuf_iterator<char>() };
58static std::vector<uint8_t> loadBinaryFixture(
const std::string& aName )
62 return { std::istreambuf_iterator<char>( file ), std::istreambuf_iterator<char>() };
66static uint32_t readU32(
const std::vector<uint8_t>& aBytes,
size_t aOffset )
68 return static_cast<uint32_t
>( aBytes[aOffset] ) | (
static_cast<uint32_t
>( aBytes[aOffset + 1] ) << 8 )
69 | (
static_cast<uint32_t
>( aBytes[aOffset + 2] ) << 16 )
70 | (
static_cast<uint32_t
>( aBytes[aOffset + 3] ) << 24 );
74static uint16_t readU16(
const std::vector<uint8_t>& aBytes,
size_t aOffset )
76 return static_cast<uint16_t
>( aBytes[aOffset] ) | (
static_cast<uint16_t
>( aBytes[aOffset + 1] ) << 8 );
80static void writeU16( std::vector<uint8_t>& aBytes,
size_t aOffset, uint16_t aValue )
82 aBytes[aOffset] =
static_cast<uint8_t
>( aValue );
83 aBytes[aOffset + 1] =
static_cast<uint8_t
>( aValue >> 8 );
87static void writeU32( std::vector<uint8_t>& aBytes,
size_t aOffset, uint32_t aValue )
89 writeU16( aBytes, aOffset,
static_cast<uint16_t
>( aValue ) );
90 writeU16( aBytes, aOffset + 2,
static_cast<uint16_t
>( aValue >> 16 ) );
94static size_t outerControllerOffset(
const std::vector<uint8_t>& aBytes,
size_t aController )
96 size_t offset = 0x254;
98 for(
size_t controller = 1; controller < aController; ++controller )
99 offset += readU32( aBytes, 0x20 + controller * 28 + 12 );
105static size_t sheetControllerOffset(
const std::vector<uint8_t>& aBytes,
size_t aController )
107 const size_t sheetOffset = readU32( aBytes, outerControllerOffset( aBytes, 3 ) );
108 size_t offset = sheetOffset + 20 + 24 * 28;
110 for(
size_t controller = 1; controller < aController; ++controller )
111 offset += readU32( aBytes, sheetOffset + 20 + ( controller - 1 ) * 28 + 16 );
117static uint32_t sheetControllerCount(
const std::vector<uint8_t>& aBytes,
size_t aController )
119 const size_t sheetOffset = readU32( aBytes, outerControllerOffset( aBytes, 3 ) );
120 return readU32( aBytes, sheetOffset + 20 + ( aController - 1 ) * 28 + 12 );
124template <
typename Item>
125static const Item& itemNamed(
const std::vector<Item>& aItems,
const wxString& aName )
127 auto item = std::ranges::find_if( aItems,
128 [&](
const Item& aItem )
130 return aItem.name.text == aName;
137static wxString propertyValue(
const std::vector<SOURCE_PROPERTY>& aProperties,
const wxString& aName )
139 auto property = std::ranges::find_if( aProperties,
142 return aProperty.
name.
text == aName;
145 return property->value.text;
151 std::ostringstream out;
157 out <<
':' << aSource.version <<
',' << aSource.objectClass <<
',' << aSource.controller <<
','
158 << aSource.recordIndex <<
',' << aSource.absoluteOffset <<
',' << aSource.length <<
',' << aSource.sheet;
164 provenance( sheet.
source );
168 <<
"|placements=" << aModel.
placements.size() <<
"|nets=" << aModel.
nets.size()
169 <<
"|buses=" << aModel.
buses.size() <<
"|labels=" << aModel.
labels.size()
170 <<
"|junctions=" << aModel.
junctions.size() <<
"|texts=" << aModel.
texts.size()
176enum class CANONICAL_KIND
199using CANONICAL_VALUE = std::variant<int64_t, bool, std::string, std::vector<std::string>>;
201struct CANONICAL_PROPERTY
203 CANONICAL_VALUE value;
205 bool operator==(
const CANONICAL_PROPERTY& )
const =
default;
206 bool operator<(
const CANONICAL_PROPERTY& aOther )
const
208 return std::tie( value, disposition ) < std::tie( aOther.value, aOther.disposition );
212struct CANONICAL_POINT
214 int64_t xHalfMils = 0;
215 int64_t yHalfMils = 0;
216 bool operator==(
const CANONICAL_POINT& )
const =
default;
217 bool operator<(
const CANONICAL_POINT& aOther )
const
219 return std::tie( xHalfMils, yHalfMils ) < std::tie( aOther.xHalfMils, aOther.yHalfMils );
223struct CANONICAL_GEOMETRY
225 std::vector<CANONICAL_POINT> points;
226 std::optional<int64_t> angleTenths;
227 bool operator==(
const CANONICAL_GEOMETRY& )
const =
default;
230struct CANONICAL_SEMANTIC_RECORD
233 CANONICAL_KIND kind = CANONICAL_KIND::SETTINGS;
234 std::string stableKey;
235 std::map<std::string, CANONICAL_PROPERTY> properties;
236 CANONICAL_GEOMETRY geometry;
237 bool operator==(
const CANONICAL_SEMANTIC_RECORD& )
const =
default;
238 bool operator<(
const CANONICAL_SEMANTIC_RECORD& aOther )
const
240 return std::tie( sheet, kind, stableKey, properties, geometry.points, geometry.angleTenths )
241 < std::tie( aOther.sheet, aOther.kind, aOther.stableKey, aOther.properties, aOther.geometry.points,
242 aOther.geometry.angleTenths );
246using SNAPSHOT_ALLOWLIST = std::set<std::pair<std::string, PROPERTY_DISPOSITION>>;
248static CANONICAL_POINT point(
const SOURCE_POINT& aPoint )
250 return { aPoint.
x, aPoint.
y };
254 return {
static_cast<int64_t
>( std::llround( aPoint.
x * 2.0 ) ),
255 static_cast<int64_t
>( std::llround( aPoint.
y * 2.0 ) ) };
258static void addSourceProperties( CANONICAL_SEMANTIC_RECORD& aRecord,
const std::vector<SOURCE_PROPERTY>& aProperties,
259 const std::string& aPrefix = {} )
262 aRecord.properties[aPrefix +
property.name.text.ToStdString()] = {
property.value.text.ToStdString(),
263 property.disposition };
266static CANONICAL_PROPERTY unknownEnum( int64_t aValue )
283 return unknownEnum(
static_cast<int64_t
>( aKind ) );
297 return unknownEnum(
static_cast<int64_t
>( aKind ) );
302 if( std::ranges::any_of( aGraphic.
points,
305 return aPoint.arc.has_value();
314 return canonicalGraphicType( aGraphic.
type );
328 return unknownEnum(
static_cast<int64_t
>( aStyle ) );
331static CANONICAL_PROPERTY canonicalLineStyle(
int aStyle )
333 switch(
static_cast<int8_t
>( aStyle & 0xFF ) )
336 case -1:
return {
"solid" };
338 case -2:
return {
"dash" };
339 case -3:
return {
"dot" };
340 case -4:
return {
"dash_dot" };
341 case -5:
return {
"dash_dot_dot" };
342 default:
return unknownEnum( aStyle );
355 return unknownEnum(
static_cast<int64_t
>( aFill ) );
358static CANONICAL_PROPERTY canonicalFill(
bool aFilled )
360 return { aFilled ?
"filled" :
"none" };
363static CANONICAL_PROPERTY canonicalPinType( uint32_t aType )
367 case 0:
return {
"passive" };
368 case 1:
return {
"input" };
369 case 2:
return {
"output" };
370 case 3:
return {
"bidirectional" };
371 case 4:
return {
"tristate" };
372 case 5:
return {
"open_collector" };
373 case 6:
return {
"open_emitter" };
374 case 7:
return {
"power" };
375 case 8:
return {
"unspecified" };
376 default:
return unknownEnum( aType );
395 return unknownEnum(
static_cast<int64_t
>( aType ) );
398static CANONICAL_PROPERTY canonicalPinType(
char aType )
402 case 'U':
return {
"passive" };
403 case 'L':
return {
"input" };
404 case 'S':
return {
"output" };
405 case 'B':
return {
"bidirectional" };
406 case 'T':
return {
"tristate" };
407 case 'C':
return {
"open_collector" };
408 case 'E':
return {
"open_emitter" };
410 case 'G':
return {
"power" };
411 default:
return {
"unspecified" };
415static CANONICAL_PROPERTY canonicalPinStyle( uint32_t aStyle )
419 case 0:
return {
"normal" };
420 case 1:
return {
"inverted" };
421 case 2:
return {
"clock" };
422 case 3:
return {
"inverted_clock" };
423 default:
return unknownEnum( aStyle );
427static CANONICAL_PROPERTY canonicalPinStyle(
bool aInverted,
bool aClock )
429 return canonicalPinStyle( ( aInverted ? 1U : 0U ) | ( aClock ? 2U : 0U ) );
434 switch( aJustification )
441 return unknownEnum(
static_cast<int64_t
>( aJustification ) );
444static CANONICAL_PROPERTY canonicalVerticalJustification(
MODEL_JUSTIFICATION aJustification )
446 switch( aJustification )
453 return unknownEnum(
static_cast<int64_t
>( aJustification ) );
457static CANONICAL_PROPERTY canonicalHorizontalJustification(
int aJustification )
459 if( aJustification & 0x4 )
462 if( aJustification & 0x1 )
468static CANONICAL_PROPERTY canonicalVerticalJustification(
int aJustification )
470 if( aJustification < 0 )
471 return unknownEnum( aJustification );
473 if( aJustification & 0x8 )
476 if( aJustification & 0x2 )
495 return unknownEnum(
static_cast<int64_t
>( aKind ) );
507 return unknownEnum(
static_cast<int64_t
>( aKind ) );
510static int64_t canonicalAngle( int64_t aAngleTenths )
515static std::vector<CANONICAL_SEMANTIC_RECORD> normalizeBinaryModel(
const PADS_SCH_MODEL& aModel )
517 std::vector<CANONICAL_SEMANTIC_RECORD> out;
518 auto add = [&]( CANONICAL_KIND aKind,
int aSheet, std::string aKey = {} ) -> CANONICAL_SEMANTIC_RECORD&
520 out.push_back( { aSheet, aKind, std::move( aKey ) } );
523 auto addOwned = [&]( CANONICAL_KIND aKind,
const SHEET_REFERENCE& aSheet,
524 std::string aKey = {} ) -> CANONICAL_SEMANTIC_RECORD&
526 auto sheet = std::ranges::find_if( aModel.
sheets,
529 return aCandidate.id == aSheet.id;
532 add( aKind, sheet == aModel.
sheets.end() ? -1 :
static_cast<int>( sheet->
index ), std::move( aKey ) );
533 record.properties[
"owner_sheet"] = sheet == aModel.
sheets.end()
534 ? unknownEnum( aSheet.id.Value() )
538 auto graphic = [&](
const MODEL_GRAPHIC& aGraphic,
int aSheet )
540 auto& r = add( CANONICAL_KIND::GRAPHIC, aSheet );
541 r.properties[
"type"] = canonicalGraphicType( aGraphic.
kind );
542 r.properties[
"line_style"] = canonicalLineStyle( aGraphic.
lineStyle );
543 r.properties[
"stroke_half_mils"] = { aGraphic.
strokeWidth };
544 r.properties[
"fill"] = canonicalFill( aGraphic.
fill );
545 r.properties[
"text"] = { aGraphic.
text.
text.ToStdString() };
553 r.properties[
"arc_center_x_half_mils"] = { aGraphic.
arcCenter.
x };
554 r.properties[
"arc_center_y_half_mils"] = { aGraphic.
arcCenter.
y };
555 r.properties[
"arc_bounds_x1_half_mils"] = { aGraphic.
arcBoundsStart.
x };
556 r.properties[
"arc_bounds_y1_half_mils"] = { aGraphic.
arcBoundsStart.
y };
557 r.properties[
"arc_bounds_x2_half_mils"] = { aGraphic.
arcBoundsEnd.
x };
558 r.properties[
"arc_bounds_y2_half_mils"] = { aGraphic.
arcBoundsEnd.
y };
559 r.properties[
"arc_sweep_tenths"] = { int64_t( aGraphic.
arcSweepAngle ) };
560 r.properties[
"arc_clockwise"] = { aGraphic.
arcClockwise };
564 r.geometry.points.push_back( point( p ) );
565 r.geometry.angleTenths = canonicalAngle( aGraphic.
angle );
566 addSourceProperties( r, aGraphic.
properties );
568 auto field = [&](
const MODEL_FIELD& aField,
int aSheet )
570 auto& r = add( CANONICAL_KIND::FIELD, aSheet, aField.
name.
text.ToStdString() );
571 r.properties[
"value"] = { aField.
value.
text.ToStdString() };
572 r.properties[
"visible"] = { aField.
visible };
574 r.geometry.points.push_back( point( aField.
position ) );
575 r.geometry.angleTenths = canonicalAngle( aField.
angle );
578 auto& settings = add( CANONICAL_KIND::SETTINGS, -1 );
586 auto& r = add( CANONICAL_KIND::SHEET,
static_cast<int>( s.
index ), s.
name.
text.ToStdString() );
587 r.properties[
"title"] = { s.
title.
text.ToStdString() };
590 r.geometry.points.push_back( point( s.
pageSize ) );
592 for(
const auto& g : s.
border )
593 graphic( g,
static_cast<int>( s.
index ) );
595 field( f,
static_cast<int>( s.
index ) );
599 auto& definition = add( CANONICAL_KIND::DEFINITION, d.source.sheet, d.name.text.ToStdString() );
600 addSourceProperties( definition, d.properties );
601 for(
const auto& g : d.graphics )
602 graphic( g, d.source.sheet );
603 for(
const auto& p : d.pins )
605 auto& r = add( CANONICAL_KIND::PIN, d.source.sheet, p.number.text.ToStdString() );
606 r.properties[
"name"] = { p.name.text.ToStdString() };
607 r.properties[
"type"] = canonicalPinType( p.electricalType );
608 r.properties[
"style"] = canonicalPinStyle( p.graphicStyle );
609 r.properties[
"length_half_mils"] = { p.length };
610 r.properties[
"font"] = { p.presentation.font.text.ToStdString() };
611 r.properties[
"visible"] = { p.presentation.visible };
612 r.geometry.points.push_back( point( p.position ) );
613 r.geometry.angleTenths = canonicalAngle( p.angle );
614 addSourceProperties( r, p.properties );
616 for(
const auto& f : d.fields )
617 field( f, d.source.sheet );
621 auto& part = add( CANONICAL_KIND::PART_TYPE, p.
source.
sheet, p.name.text.ToStdString() );
622 addSourceProperties( part, p.properties );
623 for(
const auto& g : p.gates )
625 auto& r = add( CANONICAL_KIND::GATE, g.source.sheet, std::to_string( g.unit ) );
626 auto definition = std::ranges::find_if( aModel.
definitions,
629 return aDefinition.id == g.definition.id;
631 r.properties[
"definition"] = definition == aModel.
definitions.end()
632 ? unknownEnum( g.definition.id.Value() )
634 addSourceProperties( r, g.properties );
635 for(
size_t i = 0; i < g.pins.size(); ++i )
637 auto& m = add( CANONICAL_KIND::GATE_PIN_MAPPING, g.source.sheet,
638 std::to_string( g.unit ) +
":" + std::to_string( i ) );
643 auto resolved = std::ranges::find_if( definition->pins,
646 return aPin.id == g.pins[i].id;
649 if( resolved != definition->pins.end() )
655 m.properties[
"pin_number"] = {
pin->number.text.ToStdString() };
656 m.properties[
"pin_name"] = {
pin->name.text.ToStdString() };
660 m.properties[
"pin_number"] = unknownEnum( g.pins[i].id.Value() );
661 m.properties[
"pin_name"] = unknownEnum( g.pins[i].id.Value() );
665 for(
const auto& f : p.fields )
670 auto& r = addOwned( CANONICAL_KIND::PLACEMENT, p.sheet, p.reference.text.ToStdString() );
671 r.properties[
"unit"] = { int64_t( p.unit ) };
672 r.properties[
"mirrored"] = { p.mirrored };
673 r.geometry.points.push_back( point( p.position ) );
674 r.geometry.angleTenths = canonicalAngle( p.angle );
675 addSourceProperties( r, p.properties );
676 int ownerSheet = r.sheet;
677 for(
const auto& f : p.fields )
678 field( f, ownerSheet );
680 for(
const auto& n : aModel.
nets )
682 auto& net = addOwned( CANONICAL_KIND::NET, n.sheet, n.name.text.ToStdString() );
683 addSourceProperties( net, n.properties );
684 for(
const auto& c : n.connections )
686 auto& r = addOwned( CANONICAL_KIND::CONNECTION, n.sheet );
687 r.properties[
"endpoint_count"] = { int64_t( c.endpoints.size() ) };
688 for(
size_t i = 0; i < c.endpoints.size(); ++i )
690 const auto prefix =
"endpoint_" + std::to_string( i ) +
"_";
691 r.properties[prefix +
"kind"] = canonicalEndpointKind( c.endpoints[i].kind );
692 addSourceProperties( r, c.endpoints[i].properties, prefix );
694 if( c.endpoints[i].placement )
696 auto placement = std::ranges::find_if( aModel.
placements,
699 return aPlacement.id == c.endpoints[i].placement->id;
701 r.properties[prefix +
"placement"] =
703 ? unknownEnum( c.endpoints[i].placement->id.Value() )
707 if( c.endpoints[i].pin )
709 auto definition = std::ranges::find_if( aModel.
definitions,
712 return std::ranges::any_of(
714 [&]( const MODEL_PIN_DEFINITION& aPin )
716 return aPin.id == c.endpoints[i].pin->id;
719 r.properties[prefix +
"pin_number"] =
721 ? unknownEnum( c.endpoints[i].pin->id.Value() )
722 : CANONICAL_PROPERTY{
std::ranges::find_if( definition->pins,
726 == c.endpoints[i].pin->id;
728 ->number.text.ToStdString() };
731 for(
const auto& p : c.vertices )
732 r.geometry.points.push_back( point( p ) );
733 addSourceProperties( r, c.properties );
736 for(
const auto& b : aModel.
buses )
738 auto netName = [&](
NET_ID aId ) -> CANONICAL_PROPERTY
740 auto net = std::ranges::find_if( aModel.
nets,
743 return aNet.id == aId;
746 if( net == aModel.
nets.end() )
747 return unknownEnum( aId.Value() );
749 return { net->name.text.ToStdString() };
751 auto& r = addOwned( CANONICAL_KIND::BUS, b.sheet, b.name.text.ToStdString() );
752 std::vector<std::string> aliases;
753 std::vector<std::string> members;
756 aliases.push_back( alias.
text.ToStdString() );
759 members.push_back( std::get<std::string>( netName( member.
id ).value ) );
761 r.properties[
"aliases"] = { aliases };
762 r.properties[
"member_nets"] = { members };
763 for(
const auto& p : b.vertices )
764 r.geometry.points.push_back( point( p ) );
765 addSourceProperties( r, b.properties );
766 for(
size_t i = 0; i < b.entries.size(); ++i )
768 auto& e = addOwned( CANONICAL_KIND::BUS_ENTRY, b.sheet, std::to_string( i ) );
769 e.properties[
"member_index"] = { int64_t( i ) };
770 e.properties[
"member_net"] = netName( b.entries[i].memberNet.id );
771 e.geometry.points.push_back( point( b.entries[i].position ) );
772 addSourceProperties( e, b.entries[i].properties );
774 for(
const auto& a : b.aliases )
775 addOwned( CANONICAL_KIND::BUS_ALIAS, b.sheet, a.text.ToStdString() );
776 for(
size_t i = 0; i < b.memberNets.size(); ++i )
778 auto& member = addOwned( CANONICAL_KIND::BUS_MEMBER, b.sheet, std::to_string( i ) );
779 member.properties[
"member_net"] = netName( b.memberNets[i].id );
782 for(
const auto& l : aModel.
labels )
784 auto& r = addOwned( CANONICAL_KIND::LABEL, l.sheet, l.text.text.ToStdString() );
785 r.properties[
"kind"] = canonicalLabelKind( l.kind );
786 std::vector<std::string> linkedSheets;
792 if( sheet != aModel.
sheets.end() )
793 linkedSheets.push_back( std::to_string( sheet->
index ) );
796 std::ranges::sort( linkedSheets );
797 r.properties[
"linked_sheets"] = { linkedSheets };
798 r.geometry.points.push_back( point( l.position ) );
799 r.geometry.angleTenths = canonicalAngle( l.angle );
800 addSourceProperties( r, l.properties );
804 auto& r = addOwned( CANONICAL_KIND::JUNCTION, j.sheet );
805 r.geometry.points.push_back( point( j.position ) );
806 addSourceProperties( r, j.properties );
808 for(
const auto& t : aModel.
texts )
810 auto& r = addOwned( CANONICAL_KIND::TEXT, t.sheet, t.text.text.ToStdString() );
811 r.properties[
"visible"] = { t.presentation.visible };
812 r.properties[
"font"] = { t.presentation.font.text.ToStdString() };
813 r.properties[
"bold"] = { t.presentation.bold };
814 r.properties[
"italic"] = { t.presentation.italic };
815 r.properties[
"underline"] = { t.presentation.underline };
816 r.properties[
"horizontal_justification"] = canonicalJustification( t.presentation.horizontalJustification );
817 r.properties[
"vertical_justification"] = canonicalVerticalJustification( t.presentation.verticalJustification );
818 r.geometry.points.push_back( point( t.position ) );
819 r.geometry.angleTenths = canonicalAngle( t.angle );
820 addSourceProperties( r, t.properties );
824 auto& record = addOwned( CANONICAL_KIND::GRAPHIC, pageGraphic.
sheet );
825 int sheet = record.sheet;
826 auto owner = record.
properties.at(
"owner_sheet" );
828 graphic( pageGraphic.
graphic, sheet );
829 out.back().properties[
"owner_sheet"] = owner;
833 auto& record = addOwned( CANONICAL_KIND::GRAPHIC, worksheet.
sheet );
834 int sheet = record.sheet;
835 auto owner = record.properties.at(
"owner_sheet" );
840 graphic( worksheetGraphic, sheet );
841 out.back().properties[
"owner_sheet"] = owner;
848static std::string canonicalAsciiFont(
const PADS_SCH::PARAMETERS& aParameters,
const std::string& aFont )
850 if( aParameters.
font_mode !=
"System" || aFont !=
"Default Font" || aParameters.
default_font.empty() )
854 return face.starts_with(
"Regular " ) ? face.substr( 8 ) : face;
860 std::vector<CANONICAL_SEMANTIC_RECORD> out;
861 auto add = [&]( CANONICAL_KIND k,
int s, std::string key = {} ) -> CANONICAL_SEMANTIC_RECORD&
863 out.push_back( { s, k, std::move( key ) } );
867 auto addOwned = [&]( CANONICAL_KIND aKind,
int aSheet, std::string aKey = {} ) -> CANONICAL_SEMANTIC_RECORD&
872 return aCandidate.sheet_num - 1 == aSheet;
874 auto& record = add( aKind, aSheet, std::move( aKey ) );
875 record.properties[
"owner_sheet"] =
878 : CANONICAL_PROPERTY{ sheet->sheet_name };
881 auto& settings = add( CANONICAL_KIND::SETTINGS, -1 );
882 settings.properties[
"coordinate_units_per_mil"] = { int64_t( 2 ) };
884 if( !p.font_mode.empty() )
886 settings.properties[
"font_mode_raw"] =
887 p.font_mode ==
"System"
888 ? CANONICAL_PROPERTY{ std::string(
"1" ) }
892 settings.properties[
"line_width_half_mils"] = { int64_t( std::llround( p.line_width * 2 ) ) };
893 settings.properties[
"bus_width_half_mils"] = { int64_t( p.bus_width * 2 ) };
894 settings.geometry.points.push_back( point(
PADS_SCH::POINT{ p.sheet_size.width, p.sheet_size.height } ) );
897 auto& r = add( CANONICAL_KIND::GRAPHIC, aSheet );
898 r.properties[
"type"] = canonicalGraphicType( aGraphic.
type );
899 r.properties[
"line_style"] = canonicalLineStyle( aGraphic.
line_style );
900 r.properties[
"stroke_half_mils"] = { int64_t( std::llround( aGraphic.
line_width * 2 ) ) };
901 r.properties[
"fill"] = canonicalFill( aGraphic.
filled );
902 r.properties[
"text"] = { std::string() };
903 r.properties[
"font"] = { std::string() };
904 r.properties[
"visible"] = {
true };
905 r.properties[
"height_half_mils"] = { int64_t( 0 ) };
906 r.properties[
"width_half_mils"] = { int64_t( 0 ) };
908 for(
const auto& q : aGraphic.
points )
909 r.geometry.points.push_back( point( q.coord ) );
911 auto arcPoint = std::ranges::find_if( aGraphic.
points,
914 return aPoint.arc.has_value();
917 if( arcPoint != aGraphic.
points.end() )
920 r.properties[
"arc_center_x_half_mils"] = { int64_t( std::llround( ( arc.
bbox_x1 + arc.
bbox_x2 ) ) ) };
921 r.properties[
"arc_center_y_half_mils"] = { int64_t( std::llround( ( arc.
bbox_y1 + arc.
bbox_y2 ) ) ) };
922 r.properties[
"arc_bounds_x1_half_mils"] = { int64_t( std::llround( arc.
bbox_x1 * 2 ) ) };
923 r.properties[
"arc_bounds_y1_half_mils"] = { int64_t( std::llround( arc.
bbox_y1 * 2 ) ) };
924 r.properties[
"arc_bounds_x2_half_mils"] = { int64_t( std::llround( arc.
bbox_x2 * 2 ) ) };
925 r.properties[
"arc_bounds_y2_half_mils"] = { int64_t( std::llround( arc.
bbox_y2 * 2 ) ) };
926 r.properties[
"arc_sweep_tenths"] = { int64_t( std::llround(
std::abs( arc.
bulge ) ) ) };
927 r.properties[
"arc_clockwise"] = { arc.
angle < 0 };
932 auto& r = add( CANONICAL_KIND::SHEET, s.sheet_num - 1, s.sheet_name );
933 r.properties[
"title"] = { std::string() };
934 r.properties[
"line_width_half_mils"] = { int64_t( std::llround( p.line_width * 2 ) ) };
935 r.properties[
"bus_width_half_mils"] = { int64_t( p.bus_width * 2 ) };
936 r.geometry.points.push_back( point(
PADS_SCH::POINT{ p.sheet_size.width, p.sheet_size.height } ) );
940 add( CANONICAL_KIND::DEFINITION, -1, d.name );
941 for(
const auto& g : d.graphics )
943 std::vector<PADS_SCH::SYMBOL_PIN> pins = d.pins;
945 for(
const auto& [partName, part] : aParser.
GetPartTypes() )
952 for(
size_t i = 0; i < pins.size(); ++i )
954 pins[i].number = gate.
pins[i].pin_id;
955 pins[i].name = gate.
pins[i].pin_name;
956 switch( gate.
pins[i].pin_type )
975 for(
const auto&
pin : pins )
977 auto& r = add( CANONICAL_KIND::PIN, -1,
pin.number );
978 r.properties[
"name"] = {
pin.name };
979 r.properties[
"type"] = canonicalPinType(
pin.type );
980 r.properties[
"style"] = canonicalPinStyle(
pin.inverted,
pin.clock );
981 r.properties[
"length_half_mils"] = { int64_t( std::llround(
pin.length * 2 ) ) };
982 r.geometry.points.push_back( point(
pin.position ) );
983 r.geometry.angleTenths = canonicalAngle( std::llround(
pin.rotation * 10 ) );
985 for(
const auto& t : d.texts )
987 auto& r = add( CANONICAL_KIND::GRAPHIC, -1 );
988 r.properties[
"type"] = {
"text" };
989 r.properties[
"line_style"] = {
"solid" };
990 r.properties[
"stroke_half_mils"] = { int64_t( 0 ) };
991 r.properties[
"fill"] = {
"none" };
992 r.properties[
"text"] = { t.content };
993 r.properties[
"visible"] = { t.visible };
994 r.properties[
"font"] = { canonicalAsciiFont( p, t.font_name ) };
995 r.properties[
"height_half_mils"] = { int64_t( std::llround( t.size * 2 ) ) };
996 r.properties[
"width_half_mils"] = { int64_t( t.width_factor * 2 ) };
997 r.geometry.points.push_back( point( t.position ) );
998 r.geometry.angleTenths = canonicalAngle( std::llround( t.rotation * 10 ) );
1003 add( CANONICAL_KIND::PART_TYPE, -1,
name );
1004 for(
size_t i = 0; i < part.gates.size(); ++i )
1006 auto& gate = add( CANONICAL_KIND::GATE, -1, std::to_string( i + 1 ) );
1007 gate.properties[
"definition"] = { part.gates[i].decal_names.empty() ? std::string()
1008 : part.gates[i].decal_names.front() };
1009 for(
size_t j = 0; j < part.gates[i].pins.size(); ++j )
1011 auto& r = add( CANONICAL_KIND::GATE_PIN_MAPPING, -1,
1012 std::to_string( i + 1 ) +
":" + std::to_string( j ) );
1013 r.properties[
"pin_number"] = { part.gates[i].pins[j].pin_id };
1014 r.properties[
"pin_name"] = { part.gates[i].pins[j].pin_name };
1020 auto& r = addOwned( CANONICAL_KIND::PLACEMENT, x.sheet_number - 1, x.reference );
1021 r.properties[
"unit"] = { int64_t( x.gate_number ) };
1022 r.properties[
"mirrored"] = { x.mirror_flags != 0 };
1023 r.geometry.points.push_back( point( x.position ) );
1024 r.geometry.angleTenths = canonicalAngle( std::llround( x.rotation * 10 ) );
1025 int ownerSheet = r.sheet;
1026 for(
const auto& f : x.attributes )
1028 auto& q = add( CANONICAL_KIND::FIELD, ownerSheet, f.name );
1029 q.properties[
"value"] = { f.value };
1030 q.properties[
"visible"] = { f.visible };
1031 q.properties[
"font"] = { canonicalAsciiFont( p, f.font_name ) };
1032 q.geometry.points.push_back( point( f.position ) );
1033 q.geometry.angleTenths = canonicalAngle( std::llround( f.rotation * 10 ) );
1038 if( n.flags1 == 5 && n.flags2 == 3 )
1041 int netSheet = n.wires.empty() ? -1 : n.wires.front().sheet_number - 1;
1042 addOwned( CANONICAL_KIND::NET, netSheet, n.name );
1043 for(
const auto& c : n.wires )
1045 auto& r = addOwned( CANONICAL_KIND::CONNECTION, c.sheet_number - 1 );
1046 r.properties[
"endpoint_count"] = { int64_t( 2 ) };
1048 const std::array<std::string, 2> endpoints = { c.endpoint_a, c.endpoint_b };
1050 for(
size_t endpoint = 0; endpoint < endpoints.size(); ++endpoint )
1052 const std::string prefix =
"endpoint_" + std::to_string( endpoint ) +
"_";
1053 const std::string& token = endpoints[endpoint];
1055 if( token.starts_with(
"@@@" ) )
1061 const size_t separator = token.rfind(
'.' );
1063 r.properties[prefix +
"placement"] = { token.substr( 0, separator ) };
1064 r.properties[prefix +
"pin_number"] = { token.substr( separator + 1 ) };
1068 for(
const auto& q : c.vertices )
1069 r.geometry.points.push_back( point( q ) );
1072 for(
const auto& b : aParser.
GetBuses() )
1074 auto& r = addOwned( CANONICAL_KIND::BUS, b.sheet_number - 1, b.name );
1075 r.properties[
"aliases"] = { b.aliases };
1076 r.properties[
"member_nets"] = { b.member_nets };
1077 for(
const auto& q : b.path )
1078 r.geometry.points.push_back( point( q ) );
1079 for(
size_t i = 0; i < b.entries.size(); ++i )
1081 auto& e = addOwned( CANONICAL_KIND::BUS_ENTRY, b.sheet_number - 1, std::to_string( i ) );
1082 e.properties[
"member_index"] = { int64_t( i ) };
1083 e.properties[
"member_net"] = { b.entries[i].member_net };
1084 e.geometry.points.push_back( point( b.entries[i].position ) );
1086 for(
const auto& a : b.aliases )
1087 addOwned( CANONICAL_KIND::BUS_ALIAS, b.sheet_number - 1, a );
1088 for(
size_t i = 0; i < b.member_nets.size(); ++i )
1090 auto& member = addOwned( CANONICAL_KIND::BUS_MEMBER, b.sheet_number - 1, std::to_string( i ) );
1091 member.properties[
"member_net"] = { b.member_nets[i] };
1093 if( std::ranges::none_of( aParser.
GetSignals(),
1096 return aSignal.name == b.member_nets[i];
1099 addOwned( CANONICAL_KIND::NET, b.sheet_number - 1, b.member_nets[i] );
1105 if( l.symbol_lib.starts_with(
"@@@B" ) )
1107 auto& r = addOwned( CANONICAL_KIND::LABEL, l.source_sheet - 1, l.signal_name );
1108 r.properties[
"kind"] = { l.symbol_lib ==
"@TERM" ?
"local"
1109 : l.symbol_lib.starts_with(
"$OSR" ) ?
"global"
1110 : l.symbol_lib.starts_with(
"$GND" ) ?
"ground"
1111 : l.symbol_lib.starts_with(
"$PWR" ) ?
"power"
1113 std::vector<std::string> linkedSheets;
1115 if( l.symbol_lib.starts_with(
"$OSR" ) )
1119 if( peer.signal_name != l.signal_name || peer.source_sheet == l.source_sheet
1120 || !peer.symbol_lib.starts_with(
"$OSR" ) )
1128 return aHeader.sheet_num == peer.source_sheet;
1132 linkedSheets.push_back( std::to_string( sheet->sheet_num - 1 ) );
1136 std::ranges::sort( linkedSheets );
1137 r.properties[
"linked_sheets"] = { linkedSheets };
1138 r.geometry.points.push_back( point( l.position ) );
1139 r.geometry.angleTenths = canonicalAngle( l.rotation * 10 );
1142 addOwned( CANONICAL_KIND::JUNCTION, j.sheet_number - 1 ).geometry.points.push_back( point( j.position ) );
1145 auto& r = addOwned( CANONICAL_KIND::TEXT, t.sheet_number - 1, t.content );
1146 r.properties[
"visible"] = {
true };
1147 r.properties[
"bold"] = {
false };
1148 r.properties[
"italic"] = {
false };
1149 r.properties[
"underline"] = {
false };
1150 r.geometry.points.push_back( point( t.position ) );
1151 r.geometry.angleTenths = canonicalAngle( t.rotation * 10 );
1155 for(
const auto& g : lines.primitives )
1157 auto& owner = addOwned( CANONICAL_KIND::GRAPHIC, lines.sheet_number - 1 );
1158 auto property = owner.properties.at(
"owner_sheet" );
1160 addGraphic( g, lines.sheet_number - 1 );
1161 out.back().properties[
"owner_sheet"] = property;
1162 out.back().properties[
"page_graphic_group"] = { lines.name };
1163 out.back().properties[
"type"] = canonicalGraphicType( g );
1165 for( CANONICAL_POINT& graphicPoint : out.back().geometry.points )
1167 graphicPoint.xHalfMils += std::llround( lines.origin.x * 2 );
1168 graphicPoint.yHalfMils += std::llround( lines.origin.y * 2 );
1171 for(
const std::string&
name :
1172 {
"arc_center_x_half_mils",
"arc_bounds_x1_half_mils",
"arc_bounds_x2_half_mils" } )
1174 auto property = out.back().properties.find(
name );
1176 if( property != out.back().properties.end() )
1177 std::get<int64_t>( property->second.value ) += std::llround( lines.origin.x * 2 );
1180 for(
const std::string&
name :
1181 {
"arc_center_y_half_mils",
"arc_bounds_y1_half_mils",
"arc_bounds_y2_half_mils" } )
1183 auto property = out.back().properties.find(
name );
1185 if( property != out.back().properties.end() )
1186 std::get<int64_t>( property->second.value ) += std::llround( lines.origin.y * 2 );
1193 if( out.back().geometry.points.size() == 2 )
1195 const CANONICAL_POINT first = out.back().geometry.points.front();
1196 const CANONICAL_POINT last = out.back().geometry.points.back();
1197 out.back().geometry.points = { { last.xHalfMils, last.yHalfMils },
1198 { first.xHalfMils, last.yHalfMils },
1199 { first.xHalfMils, first.yHalfMils },
1200 { last.xHalfMils, first.yHalfMils },
1201 { last.xHalfMils, last.yHalfMils } };
1205 out.back().geometry.angleTenths = 0;
1208 for(
const auto& t : lines.texts )
1210 auto& r = addOwned( CANONICAL_KIND::GRAPHIC, lines.sheet_number - 1 );
1213 r.properties[
"stroke_half_mils"] = { int64_t( 0 ) };
1215 r.properties[
"text"] = { t.content };
1216 r.properties[
"page_graphic_group"] = { lines.name };
1217 r.properties[
"visible"] = {
true };
1218 r.properties[
"height_half_mils"] = { int64_t( t.height * 2 ) };
1219 r.properties[
"width_half_mils"] = { int64_t( t.width_factor * 2 ) };
1220 r.properties[
"font"] = { canonicalAsciiFont( p, t.font_name ) };
1221 r.geometry.points.push_back( point( t.position ) );
1222 r.geometry.points.back().xHalfMils += std::llround( lines.origin.x * 2 );
1223 r.geometry.points.back().yHalfMils += std::llround( lines.origin.y * 2 );
1224 r.geometry.angleTenths = canonicalAngle( t.rotation * 10 );
1229 auto& r = addOwned( CANONICAL_KIND::LABEL, -1, label.net_name );
1230 r.properties[
"kind"] = {
"local" };
1231 r.properties[
"visible"] = {
true };
1232 r.properties[
"font"] = { canonicalAsciiFont( p, label.font_name ) };
1233 r.properties[
"horizontal_justification"] = canonicalHorizontalJustification( label.justification );
1234 r.properties[
"vertical_justification"] = canonicalVerticalJustification( label.justification );
1235 r.geometry.points.push_back( point(
PADS_SCH::POINT{ double( label.x_offset ), double( label.y_offset ) } ) );
1236 r.geometry.angleTenths = canonicalAngle( label.rotation * 10 );
1241static bool snapshotsMatch( std::vector<CANONICAL_SEMANTIC_RECORD> aExpected,
1242 std::vector<CANONICAL_SEMANTIC_RECORD> aActual,
1243 const SNAPSHOT_ALLOWLIST& aAllowedDifferences = {} )
1245 auto strip = [&](
auto& records )
1247 for(
auto& record : records )
1248 std::erase_if( record.properties,
1249 [&](
const auto& p )
1251 return aAllowedDifferences.contains( { p.first, p.second.disposition } );
1253 std::sort( records.begin(), records.end() );
1257 return aExpected == aActual;
1261static bool task10SourcePropertiesPresent(
const std::vector<CANONICAL_SEMANTIC_RECORD>& aRecords )
1264 [](
const CANONICAL_SEMANTIC_RECORD& aRecord,
const std::string& aName,
PROPERTY_DISPOSITION aDisposition )
1266 auto property = aRecord.properties.find( aName );
1267 return property != aRecord.properties.end() &&
property->second.disposition == aDisposition;
1270 for(
const CANONICAL_SEMANTIC_RECORD& record : aRecords )
1272 if( record.kind == CANONICAL_KIND::NET
1280 if( record.kind == CANONICAL_KIND::CONNECTION
1295 if( record.kind == CANONICAL_KIND::JUNCTION
1301 if( record.kind == CANONICAL_KIND::BUS
1321 std::vector<uint8_t>
bytes = loadBinaryFixture(
"ole_images.sch" );
1329 BOOST_CHECK( (
model.images[0].extent == std::array<int32_t, 4>{ 30, 30, 350, 210 } ) );
1330 BOOST_CHECK( (
model.images[0].databaseBox == std::array<int32_t, 4>{ -15766, -10366, -13296, -11755 } ) );
1336 BOOST_REQUIRE_GE(
model.images[0].data.size(), 2 );
1341 BOOST_CHECK_GT(
model.images[0].source.absoluteOffset, 0 );
1342 BOOST_CHECK_GT(
model.images[0].source.length, 512 );
1348 BOOST_CHECK( (
model.images[1].extent == std::array<int32_t, 4>{ 30, 30, 170, 84 } ) );
1349 BOOST_CHECK( (
model.images[1].databaseBox == std::array<int32_t, 4>{ -15766, -10366, -14686, -10782 } ) );
1355 BOOST_REQUIRE_GE(
model.images[1].data.size(), 4 );
1364 std::vector<uint8_t> zeroWidth =
bytes;
1365 writeU32( zeroWidth, sdb.
OleItems()[0].boxOffset + 8,
static_cast<uint32_t
>( sdb.
OleItems()[0].left ) );
1372 return aDiagnostic.source.objectClass
1373 == wxS(
"embedded OLE image database box" )
1374 && aDiagnostic.message.Contains( wxS(
"zero-size" ) );
1382 PADS_SCH_MODEL minimal = parser.
Parse( loadBinaryFixture(
"minimal_v13.sch" ), wxS(
"minimal_v13.sch" ) );
1408 const std::array<wxString, 14> titleNames = { wxS(
"Drawn By" ), wxS(
"Checked By" ), wxS(
"QC By" ),
1409 wxS(
"Released By" ), wxS(
"Drawn Date" ), wxS(
"Checked Date" ),
1410 wxS(
"QC Date" ), wxS(
"Release Date" ), wxS(
"Company Name" ),
1411 wxS(
"Title" ), wxS(
"Code" ), wxS(
"Drawing Number" ),
1412 wxS(
"Revision" ), wxS(
"Scale" ) };
1413 const std::array<size_t, 14> titleOffsets = { 0x254, 0x264, 0x276, 0x283, 0x296, 0x2A8, 0x2BC,
1414 0x2CB, 0x2DF, 0x2F3, 0x300, 0x30C, 0x322, 0x332 };
1415 const std::array<size_t, 14> titleLengths = { 16, 18, 13, 19, 18, 20, 15, 20, 20, 13, 12, 22, 16, 13 };
1417 for(
size_t i = 0; i < titleNames.size(); ++i )
1420 const std::string expectedName = titleNames[i].ToStdString();
1424 expectedName.end() );
1453 parser.
Parse( loadBinaryFixture(
"multisheet_connectivity.sch" ), wxS(
"multisheet_connectivity.sch" ) );
1459 BOOST_CHECK_LT( multisheet.
sheets[0].source.absoluteOffset, multisheet.
sheets[1].source.absoluteOffset );
1479 return aField.name.text == wxS(
"Title" );
1489 std::vector<uint8_t>
bytes = loadBinaryFixture(
"minimal_v13.sch" );
1490 const size_t poolOffset = outerControllerOffset(
bytes, 1 );
1491 const size_t poolBytes = readU32(
bytes, 0x20 + 1 * 28 + 12 );
1492 const std::array<std::pair<std::string, std::string>, 5>
expected = {
1493 std::pair{
"Drawn By",
"Alice" }, std::pair{
"Checked By",
"Bob" }, std::pair{
"Title",
"Variable Title" },
1494 std::pair{
"Revision",
"C" }, std::pair{
"Scale",
"2:1" }
1496 std::vector<uint8_t> pool;
1497 std::array<size_t,
expected.size()> offsets;
1498 std::array<size_t,
expected.size()> lengths;
1500 for(
size_t i = 0; i <
expected.size(); ++i )
1502 offsets[i] = poolOffset + pool.size();
1503 const std::string slot =
"Field\n" +
expected[i].first +
'\x01' +
expected[i].second +
'\0';
1504 lengths[i] = slot.size();
1505 pool.insert( pool.end(), slot.begin(), slot.end() );
1508 const size_t firstNonFieldOffset = poolOffset + pool.size();
1509 const std::string firstNonField(
"Font Default\0", 13 );
1510 pool.insert( pool.end(), firstNonField.begin(), firstNonField.end() );
1511 BOOST_REQUIRE_LE( pool.size(), poolBytes );
1512 pool.resize( poolBytes, 0 );
1513 std::copy( pool.begin(), pool.end(),
bytes.begin() + poolOffset );
1520 for(
size_t i = 0; i <
expected.size(); ++i )
1550 bytes.begin() + firstNonFieldOffset + firstNonField.size(), firstNonField.begin(),
1551 firstNonField.end() );
1553 +
model.sheets[0].titleBlockFields.back().source.length,
1554 firstNonFieldOffset );
1593 std::vector<uint8_t> cp1252Bytes = loadBinaryFixture(
"text_encoding.sch" );
1594 cp1252Bytes[
text.text.source.absoluteOffset +
text.text.source.length - 1] = 0xE9;
1606 std::vector<uint8_t> invalidOffset = loadBinaryFixture(
"text_encoding.sch" );
1607 writeU32( invalidOffset,
text.source.absoluteOffset + 8, std::numeric_limits<uint32_t>::max() );
1608 BOOST_CHECK_EXCEPTION( parser.
Parse( invalidOffset, wxS(
"invalid-offset.sch" ) ),
IO_ERROR,
1611 return aError.
What().Contains( wxString::Format( wxS(
"offset 0x%zX" ),
1612 text.source.absoluteOffset + 8 ) )
1613 && aError.
What().Contains( wxS(
"string offset leaves controller 2" ) );
1616 std::vector<uint8_t> invalidLength = loadBinaryFixture(
"text_encoding.sch" );
1617 writeU16( invalidLength,
text.source.absoluteOffset + 20, std::numeric_limits<uint16_t>::max() );
1618 BOOST_CHECK_EXCEPTION( parser.
Parse( invalidLength, wxS(
"invalid-length.sch" ) ),
IO_ERROR,
1621 return aError.
What().Contains( wxString::Format( wxS(
"offset 0x%zX" ),
1622 text.source.absoluteOffset + 20 ) )
1623 && aError.
What().Contains( wxS(
"string length leaves controller 2" ) );
1626 std::vector<uint8_t> missingNul = loadBinaryFixture(
"text_encoding.sch" );
1627 const size_t terminatorOffset =
text.text.source.absoluteOffset +
text.text.source.length;
1628 missingNul[terminatorOffset] =
'X';
1629 BOOST_CHECK_EXCEPTION( parser.
Parse( missingNul, wxS(
"missing-nul.sch" ) ),
IO_ERROR,
1632 return aError.
What().Contains(
1633 wxString::Format( wxS(
"offset 0x%zX" ), terminatorOffset ) )
1634 && aError.
What().Contains( wxS(
"not NUL terminated" ) )
1635 && aError.
What().Contains( wxS(
"controller 2" ) );
1640 std::vector<CANONICAL_SEMANTIC_RECORD>
expected = normalizeAsciiModel( ascii );
1641 std::vector<CANONICAL_SEMANTIC_RECORD>
actual = normalizeBinaryModel(
model );
1642 auto retainTask7Properties = []( std::vector<CANONICAL_SEMANTIC_RECORD>& aRecords )
1644 std::erase_if( aRecords,
1645 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
1647 return aRecord.kind != CANONICAL_KIND::SETTINGS && aRecord.kind != CANONICAL_KIND::SHEET
1648 && ( aRecord.kind != CANONICAL_KIND::TEXT
1649 || aRecord.stableKey !=
"ascii-text cafe=" );
1652 for( CANONICAL_SEMANTIC_RECORD& record : aRecords )
1654 if( record.kind != CANONICAL_KIND::TEXT )
1657 std::erase_if( record.properties,
1658 [](
const auto& aProperty )
1660 return aProperty.first !=
"owner_sheet" && aProperty.first !=
"visible"
1661 && aProperty.first !=
"bold" && aProperty.first !=
"italic"
1662 && aProperty.first !=
"underline";
1667 retainTask7Properties(
actual );
1670 std::vector<uint8_t> changedRelationship = loadBinaryFixture(
"text_encoding.sch" );
1671 writeU16( changedRelationship,
text.source.absoluteOffset + 28, 0xBEEF );
1682 struct JUSTIFICATION_CASE
1689 for(
const JUSTIFICATION_CASE&
expected :
1698 std::vector<uint8_t> changedJustification = loadBinaryFixture(
"text_encoding.sch" );
1699 writeU16( changedJustification,
text.source.absoluteOffset + 18,
expected.raw );
1700 PADS_SCH_MODEL justified = parser.
Parse( changedJustification, wxS(
"text_encoding.sch" ) );
1714 for(
const FONT_CASE&
expected : { FONT_CASE{ 0,
false,
false }, FONT_CASE{ 1,
false,
true },
1715 FONT_CASE{ 2,
true,
false }, FONT_CASE{ 3,
true,
true } } )
1717 std::vector<uint8_t> changedFont = loadBinaryFixture(
"text_encoding.sch" );
1718 writeU16( changedFont,
text.source.absoluteOffset, 0 );
1719 writeU32( changedFont, outerControllerOffset( changedFont, 19 ),
expected.style );
1727 std::vector<uint8_t> hiddenText = loadBinaryFixture(
"text_encoding.sch" );
1728 hiddenText[
text.source.absoluteOffset + 31] = 1;
1743 auto textByName = [&](
const wxString& aName ) ->
const MODEL_TEXT&
1745 auto found = std::ranges::find_if(
model.texts,
1748 return aText.text.text == aName;
1758 const std::array<MODEL_JUSTIFICATION, 16> horizontal = {
L, R,
L, R,
C,
C,
C,
C,
L, R,
L, R,
C,
C,
C,
C };
1759 const std::array<MODEL_JUSTIFICATION, 16> vertical = { R, R,
L,
L, R, R,
L,
L,
C,
C,
C,
C,
C,
C,
C,
C };
1761 for(
size_t ii = 0; ii < horizontal.size(); ++ii )
1763 const MODEL_TEXT&
text = textByName( wxString::Format( wxS(
"JUST_%02zu" ), ii ) );
1764 BOOST_CHECK(
text.presentation.horizontalJustification == horizontal[ii] );
1765 BOOST_CHECK(
text.presentation.verticalJustification == vertical[ii] );
1768 for(
const auto& [
name, angle] : { std::pair{ wxS(
"ANGLE_000" ), 0 }, std::pair{ wxS(
"ANGLE_090" ), 900 },
1769 std::pair{ wxS(
"ANGLE_180" ), 1800 }, std::pair{ wxS(
"ANGLE_270" ), 2700 } } )
1774 BOOST_CHECK( !textByName( wxS(
"STYLE_REGULAR" ) ).presentation.bold );
1775 BOOST_CHECK( !textByName( wxS(
"STYLE_REGULAR" ) ).presentation.italic );
1776 BOOST_CHECK( textByName( wxS(
"STYLE_BOLD" ) ).presentation.bold );
1777 BOOST_CHECK( textByName( wxS(
"STYLE_ITALIC" ) ).presentation.italic );
1778 BOOST_CHECK( textByName( wxS(
"STYLE_BOLD_ITALIC" ) ).presentation.bold );
1779 BOOST_CHECK( !textByName( wxS(
"STYLE_BOLD_ITALIC" ) ).presentation.italic );
1781 BOOST_CHECK( textByName( wxS(
"VISIBLE_0" ) ).presentation.visible );
1782 BOOST_CHECK( !textByName( wxS(
"VISIBLE_1" ) ).presentation.visible );
1791 wxS(
"visibility_options.sch" ) );
1793 auto underlined = std::ranges::find_if(
model.texts,
1796 return aText.text.text == wxS(
"STYLE_UNDERLINE" );
1799 BOOST_CHECK( underlined->presentation.underline );
1806 for( uint8_t flags = 0; flags < 32; ++flags )
1808 const wxString reference = wxString::Format( wxS(
"R%u" ), flags + 1 );
1809 auto placement = std::ranges::find(
model.placements, reference,
1812 return aPlacement.reference.text;
1827 std::vector<PARSER_DIAGNOSTIC> diagnostics;
1845 std::vector<uint8_t> reordered = loadBinaryFixture(
"multisheet_connectivity.sch" );
1846 size_t sheetIndex = outerControllerOffset( reordered, 3 );
1847 writeU16( reordered, sheetIndex + 8, 2 );
1848 writeU16( reordered, sheetIndex + 48 + 8, 1 );
1858 std::vector<uint8_t>
duplicate = loadBinaryFixture(
"multisheet_connectivity.sch" );
1859 sheetIndex = outerControllerOffset(
duplicate, 3 );
1860 writeU16(
duplicate, sheetIndex + 48 + 8, 1 );
1864 return aError.
What().Contains( wxS(
"duplicate sheet ID 1" ) )
1865 && aError.
What().Contains( wxS(
"controller 3" ) );
1868 std::vector<uint8_t> wrongClassBytes = loadMinimalV13();
1869 sheetIndex = outerControllerOffset( wrongClassBytes, 3 );
1870 writeU32( wrongClassBytes, sheetIndex,
static_cast<uint32_t
>( outerControllerOffset( wrongClassBytes, 5 ) ) );
1871 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongClassBytes, wxS(
"wrong-class.sch" ) ),
IO_ERROR,
1874 return aError.
What().Contains( wxS(
"references the wrong SDB object class" ) )
1875 && aError.
What().Contains( wxS(
"controller 3" ) );
1879 SOURCE_PROVENANCE refSource{ wxS(
"wrong-class.sch" ), 0x000D, wxS(
"free text" ), 1, 0, 0x100, 32, 0 };
1880 wrongClass.texts.push_back( { refSource, {
SHEET_ID( 99 ), refSource } } );
1881 BOOST_CHECK_EXCEPTION( wrongClass.ValidateOrThrow(),
IO_ERROR,
1884 return aError.What().Contains( wxS(
"unresolved text sheet reference" ) );
1892 return aError.What().Contains( wxS(
"cyclic sheet hierarchy" ) );
1896 longHierarchy.
version = 0x000D;
1897 constexpr size_t hierarchySize = 4096;
1898 longHierarchy.
sheets.reserve( hierarchySize );
1900 for(
size_t i = 0; i < hierarchySize; ++i )
1903 static_cast<int>( i ) };
1912 longHierarchy.
sheets.push_back( std::move( sheet ) );
1920 return aError.What().Contains( wxS(
"cyclic sheet hierarchy" ) )
1921 && aError.What().Contains( wxS(
"controller 3" ) );
1928 static_assert( !std::is_same_v<SHEET_ID, PLACEMENT_ID> );
1929 static_assert( !std::is_convertible_v<SHEET_ID, PLACEMENT_ID> );
1931 const std::vector<uint8_t>
bytes = loadMinimalV13();
1941 BOOST_CHECK_GT( first.
sheets[0].source.length, 0 );
1971 return aError.What().Contains( wxS(
"unresolved" ) );
1979 return aError.What().Contains( wxS(
"cyclic" ) )
1980 && aError.What().Contains( wxS(
"offset" ) );
1983 SOURCE_PROVENANCE textSource{ wxS(
"strings.sch" ), 0x000D, wxS(
"text" ), 4, 7, 0x1234, 2, 0 };
1984 std::vector<PARSER_DIAGNOSTIC> diagnostics;
2001 model.version = 0x000D;
2007 model.partTypes[0].gates.push_back(
2017 model.nets[0].connections.push_back( {
source } );
2021 BOOST_CHECK_NO_THROW(
model.ValidateOrThrow() );
2043 SOURCE_PROVENANCE topologySource{ wxS(
"model.sch" ), 0x000D, wxS(
"endpoint" ), 9, 4, 0x280, 16, 1 };
2045 crossSheet.
sheets.push_back( {
SHEET_ID( 1 ), 1, topologySource } );
2046 crossSheet.
nets[0].sheet = {
SHEET_ID( 1 ), topologySource };
2047 crossSheet.
nets[0].connections[0].endpoints[0].source = topologySource;
2048 const wxString endpointError =
2049 FormatParserError( topologySource, wxS(
"connection endpoint placement sheet does not match net sheet" ) );
2053 return aError.What().Contains( endpointError );
2057 busModel.
nets[0].connections.clear();
2060 busModel.
buses[0].entries.push_back( { topologySource, {}, {
NET_ID( 6 ), topologySource } } );
2064 missingBusMember.
buses[0].memberNets.clear();
2065 const wxString membershipError =
2066 FormatParserError( topologySource, wxS(
"bus-entry net is absent from bus member nets" ) );
2070 return aError.What().Contains( membershipError );
2074 crossSheetBus.
sheets.push_back( {
SHEET_ID( 1 ), 1, topologySource } );
2075 crossSheetBus.
buses[0].sheet = {
SHEET_ID( 1 ), topologySource };
2076 const wxString busSheetError =
FormatParserError(
source, wxS(
"bus member-net sheet does not match bus sheet" ) );
2080 return aError.What().Contains( busSheetError );
2092 BOOST_CHECK_NO_THROW(
model.ValidateOrThrow() );
2095 auto records = normalizeBinaryModel(
model );
2096 auto record = std::ranges::find_if( records,
2097 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
2099 return aRecord.kind == CANONICAL_KIND::GRAPHIC;
2107 return aError.What().Contains( error );
2114 SOURCE_PROVENANCE firstSource{ wxS(
"ids.sch" ), 0x000D, wxS(
"sheet" ), 3, 1, 0x100, 48, 0 };
2115 SOURCE_PROVENANCE secondSource{ wxS(
"ids.sch" ), 0x000D, wxS(
"sheet" ), 3, 2, 0x200, 48, 1 };
2117 duplicate.source = { wxS(
"ids.sch" ), 0x000D, wxS(
"model" ), -1, 0, 0, 0x300, -1 };
2121 const wxString duplicateDetail =
2122 wxS(
"duplicate sheet ID 7; first at v0x000D sheet controller 3 record 1 sheet 0 offset 0x100" );
2123 const wxString duplicateError =
FormatParserError( secondSource, duplicateDetail );
2127 return aError.What().Contains( duplicateError );
2133 const wxString invalidError =
FormatParserError( secondSource, wxS(
"invalid sheet ID" ) );
2137 return aError.What().Contains( invalidError );
2145 std::vector<PARSER_DIAGNOSTIC> diagnostics;
2207 BOOST_CHECK_NE( binary.
sheets[0].id.Value(), binary.
sheets[1].id.Value() );
2208 BOOST_CHECK( normalizeBinaryModel( binary ) == normalizeBinaryModel( binary ) );
2226 std::vector<CANONICAL_SEMANTIC_RECORD>
expected = normalizeBinaryModel( binary );
2230 for( CANONICAL_SEMANTIC_RECORD& item :
actual )
2232 if( item.properties.contains(
"font" ) )
2233 item.properties.at(
"font" ).value = std::string(
"Arial" );
2235 if( item.properties.contains(
"color" ) )
2236 item.properties.at(
"color" ).value = std::string(
"red" );
2255 auto string = [&](
const wxString& aText )
2270 definition.
name = string( wxS(
"SYM" ) );
2272 definition.
pins.push_back( {
PIN_ID( 3 ),
source, string( wxS(
"1" ) ) } );
2273 definition.
fields.push_back( {
FIELD_ID( 10 ),
source, string( wxS(
"Value" ) ), string( wxS(
"R" ) ) } );
2274 model.definitions.push_back( definition );
2279 partType.
name = string( wxS(
"RES" ) );
2280 partType.
gates.push_back(
2282 partType.
fields.push_back( {
FIELD_ID( 11 ),
source, string( wxS(
"Tolerance" ) ), string( wxS(
"1%" ) ) } );
2283 model.partTypes.push_back( partType );
2288 placement.
reference = string( wxS(
"R1" ) );
2289 placement.
fields.push_back( {
FIELD_ID( 12 ),
source, string( wxS(
"Value" ) ), string( wxS(
"10k" ) ) } );
2290 model.placements.push_back( placement );
2295 net.
name = string( wxS(
"N" ) );
2297 model.nets.push_back( net );
2302 bus.
name = string( wxS(
"D[0..0]" ) );
2304 bus.
aliases.push_back(
string( wxS(
"DATA" ) ) );
2306 model.buses.push_back( bus );
2309 model.texts.push_back( {
source, {}, string( wxS(
"note" ) ) } );
2312 std::vector<CANONICAL_SEMANTIC_RECORD> binaryRecords = normalizeBinaryModel(
model );
2313 std::set<CANONICAL_KIND> binaryKinds;
2315 for(
const CANONICAL_SEMANTIC_RECORD& item : binaryRecords )
2316 binaryKinds.insert( item.kind );
2318 const std::set<CANONICAL_KIND> expectedKinds{
2319 CANONICAL_KIND::SETTINGS, CANONICAL_KIND::SHEET, CANONICAL_KIND::DEFINITION,
2320 CANONICAL_KIND::GRAPHIC, CANONICAL_KIND::PIN, CANONICAL_KIND::FIELD,
2321 CANONICAL_KIND::PART_TYPE, CANONICAL_KIND::GATE, CANONICAL_KIND::GATE_PIN_MAPPING,
2322 CANONICAL_KIND::PLACEMENT, CANONICAL_KIND::NET, CANONICAL_KIND::CONNECTION,
2323 CANONICAL_KIND::BUS, CANONICAL_KIND::BUS_ENTRY, CANONICAL_KIND::BUS_ALIAS,
2324 CANONICAL_KIND::BUS_MEMBER, CANONICAL_KIND::LABEL, CANONICAL_KIND::JUNCTION,
2325 CANONICAL_KIND::TEXT
2332 std::vector<CANONICAL_SEMANTIC_RECORD> asciiRecords = normalizeAsciiModel( asciiParser );
2334 [](
const CANONICAL_SEMANTIC_RECORD& aItem )
2336 return aItem.kind == CANONICAL_KIND::SETTINGS;
2339 [](
const CANONICAL_SEMANTIC_RECORD& aItem )
2341 return aItem.kind == CANONICAL_KIND::SHEET;
2345 std::vector<CANONICAL_SEMANTIC_RECORD> minimalBinary =
2346 normalizeBinaryModel( binaryParser.Parse( loadMinimalV13(), wxS(
"minimal_v13.sch" ) ) );
2347 auto countKind = [](
const std::vector<CANONICAL_SEMANTIC_RECORD>& aItems, CANONICAL_KIND aKind )
2349 return std::ranges::count_if( aItems,
2350 [&](
const CANONICAL_SEMANTIC_RECORD& aItem )
2352 return aItem.kind == aKind;
2356 countKind( asciiRecords, CANONICAL_KIND::SETTINGS ) );
2358 countKind( asciiRecords, CANONICAL_KIND::SHEET ) );
2369 auto string = [&](
const wxString& aText )
2385 sheet.defaultLineWidth = 20;
2386 sheet.defaultBusWidth = 50;
2387 binary.
sheets.push_back( sheet );
2389 for(
int i = 0; i < 3; ++i )
2395 net.
name = string( wxString::Format( wxS(
"DATA%d" ), i ) );
2396 binary.
nets.push_back( net );
2403 bus.
name = string( wxS(
"DATA[0..2]" ) );
2405 bus.
aliases.push_back(
string( wxS(
"DATA[0..2]" ) ) );
2407 for(
int i = 0; i < 3; ++i )
2413 binary.
buses.push_back( bus );
2414 BOOST_CHECK( snapshotsMatch( normalizeBinaryModel( binary ), normalizeAsciiModel( asciiParser ) ) );
2416 std::vector<CANONICAL_SEMANTIC_RECORD> records = normalizeBinaryModel( binary );
2417 auto entry = std::ranges::find_if( records,
2418 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
2420 return aRecord.kind == CANONICAL_KIND::BUS_ENTRY;
2423 BOOST_CHECK( entry->properties.at(
"member_net" ).value == CANONICAL_VALUE( std::string(
"DATA0" ) ) );
2424 auto busRecord = std::ranges::find_if( records,
2425 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
2427 return aRecord.kind == CANONICAL_KIND::BUS;
2430 BOOST_CHECK( busRecord->properties.at(
"member_nets" ).value
2431 == CANONICAL_VALUE( std::vector<std::string>{
"DATA0",
"DATA1",
"DATA2" } ) );
2434 wrongMapping.
buses[0].entries[0].memberNet.id =
NET_ID( 2 );
2435 BOOST_CHECK( !snapshotsMatch( normalizeBinaryModel( wrongMapping ), normalizeAsciiModel( asciiParser ) ) );
2438 missingMember.
buses[0].memberNets.pop_back();
2439 BOOST_CHECK( !snapshotsMatch( normalizeBinaryModel( missingMember ), normalizeAsciiModel( asciiParser ) ) );
2446 == CANONICAL_VALUE( std::string(
"rectangle" ) ) );
2448 == CANONICAL_VALUE( std::string(
"circle" ) ) );
2451 == CANONICAL_VALUE( std::string(
"polyline" ) ) );
2453 == CANONICAL_VALUE( std::string(
"rectangle" ) ) );
2455 == CANONICAL_VALUE( std::string(
"circle" ) ) );
2458 == CANONICAL_VALUE( std::string(
"polyline" ) ) );
2460 BOOST_CHECK( canonicalLineStyle( 255 ).value == CANONICAL_VALUE( std::string(
"solid" ) ) );
2461 BOOST_CHECK( canonicalLineStyle( 0 ).value == CANONICAL_VALUE( std::string(
"dash" ) ) );
2464 BOOST_CHECK( canonicalFill(
true ).value == CANONICAL_VALUE( std::string(
"filled" ) ) );
2465 BOOST_CHECK( canonicalPinType( uint32_t( 3 ) ).value == CANONICAL_VALUE( std::string(
"bidirectional" ) ) );
2467 == CANONICAL_VALUE( std::string(
"bidirectional" ) ) );
2468 BOOST_CHECK( canonicalPinStyle( 3 ).value == CANONICAL_VALUE( std::string(
"inverted_clock" ) ) );
2469 BOOST_CHECK( canonicalPinStyle(
true,
true ).value == CANONICAL_VALUE( std::string(
"inverted_clock" ) ) );
2471 == CANONICAL_VALUE( std::string(
"center" ) ) );
2472 BOOST_CHECK( canonicalHorizontalJustification( 12 ).value == CANONICAL_VALUE( std::string(
"center" ) ) );
2473 BOOST_CHECK( canonicalVerticalJustification( 12 ).value == CANONICAL_VALUE( std::string(
"center" ) ) );
2475 == CANONICAL_VALUE( std::string(
"hierarchical" ) ) );
2484 auto graphic = std::ranges::find_if( definition.graphics,
2487 return aGraphic.line_style == 255;
2490 if( graphic != definition.graphics.end() )
2492 serializedGraphic = &*graphic;
2506 auto string = [&](
const wxString& aText )
2518 definition.
pins.push_back( {
PIN_ID( 91 ),
source, string( wxS(
"A1" ) ), string( wxS(
"CLK" ) ) } );
2519 model.definitions.push_back( definition );
2524 model.partTypes.push_back( part );
2526 const auto records = normalizeBinaryModel(
model );
2527 auto mapping = std::ranges::find_if( records,
2528 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
2530 return aRecord.kind == CANONICAL_KIND::GATE_PIN_MAPPING;
2533 BOOST_CHECK( mapping->properties.at(
"pin_number" ).value == CANONICAL_VALUE( std::string(
"A1" ) ) );
2534 BOOST_CHECK( mapping->properties.at(
"pin_name" ).value == CANONICAL_VALUE( std::string(
"CLK" ) ) );
2535 BOOST_CHECK( !mapping->properties.contains(
"pin_id" ) );
2542 PADS_SCH_MODEL model = parser.
Parse( loadBinaryFixture(
"symbol_primitives.sch" ), wxS(
"symbol_primitives.sch" ) );
2581 std::vector<uint8_t> privateStroke = loadBinaryFixture(
"symbol_primitives.sch" );
2582 const size_t privatePiece =
2583 sheetControllerOffset( privateStroke, 4 ) + definition.
graphics[0].source.recordIndex * 6;
2584 writeU16( privateStroke, privatePiece + 4, 0xEF03 );
2585 PADS_SCH_MODEL preservedStroke = parser.
Parse( privateStroke, wxS(
"private-symbol-stroke.sch" ) );
2587 itemNamed( preservedStroke.
definitions, wxS(
"BATCHB_PRIMITIVES" ) );
2588 auto privateGraphic = std::ranges::find_if( preservedDefinition.
graphics,
2591 return aGraphic.source.controller == 4
2592 && aGraphic.source.recordIndex
2593 == definition.graphics[0].source.recordIndex;
2597 auto rawStroke = std::ranges::find_if( privateGraphic->properties,
2600 return aProperty.name.text == wxS(
"unsupported_graphic_stroke_width" );
2602 BOOST_REQUIRE( rawStroke != privateGraphic->properties.end() );
2607 BOOST_CHECK_EQUAL( propertyValue( privateGraphic->properties, wxS(
"preserved_graphic_presentation" ) ),
2615 std::vector<uint8_t> fixture = loadBinaryFixture(
"pin_styles.sch" );
2618 itemNamed( baseline.
definitions, wxS(
"BATCHB_PIN_STYLES" ) ).pins[0];
2621 writeU16( fixture, visibilityOffset, 0x8040 );
2622 PADS_SCH_MODEL visibilityOnly = parser.
Parse( fixture, wxS(
"terminal-visibility-only.sch" ) );
2624 itemNamed( visibilityOnly.
definitions, wxS(
"BATCHB_PIN_STYLES" ) ).pins[0];
2630 return aDiagnostic.message.Contains(
2631 wxS(
"terminal number-offset presentation" ) )
2632 && aDiagnostic.source.controller == 8
2633 && aDiagnostic.source.recordIndex
2634 == baselinePin.source.recordIndex;
2637 writeU16( fixture, visibilityOffset, 0x0D40 );
2638 PADS_SCH_MODEL pairedPresentation = parser.
Parse( fixture, wxS(
"terminal-presentation-0d.sch" ) );
2640 itemNamed( pairedPresentation.
definitions, wxS(
"BATCHB_PIN_STYLES" ) ).pins[0];
2650 return ( aDiagnostic.message.Contains(
2651 wxS(
"terminal name-offset presentation" ) )
2652 || aDiagnostic.message.Contains(
2653 wxS(
"terminal number-offset presentation" ) ) )
2654 && aDiagnostic.source.controller == 8
2655 && aDiagnostic.source.recordIndex
2656 == baselinePin.source.recordIndex;
2664 PADS_SCH_MODEL pins = parser.
Parse( loadBinaryFixture(
"pin_styles.sch" ), wxS(
"pin_styles.sch" ) );
2681 BOOST_CHECK_EQUAL( propertyValue( pinDefinition.
pins[0].properties, wxS(
"pin_name_height_half_mils" ) ),
2683 BOOST_CHECK_EQUAL( propertyValue( pinDefinition.
pins[0].properties, wxS(
"pin_number_height_half_mils" ) ),
2685 BOOST_CHECK_EQUAL( propertyValue( pinDefinition.
pins[0].properties, wxS(
"terminal_p_line_position_1" ) ),
2686 wxS(
"-200,-100" ) );
2687 BOOST_CHECK_EQUAL( propertyValue( pinDefinition.
pins[0].properties, wxS(
"terminal_p_line_position_2" ) ),
2688 wxS(
"500,-100" ) );
2703 PADS_SCH_MODEL multi = parser.
Parse( loadBinaryFixture(
"multigate.sch" ), wxS(
"multigate.sch" ) );
2716 PADS_SCH_MODEL connectorModel = parser.
Parse( loadBinaryFixture(
"connectors.sch" ), wxS(
"connectors.sch" ) );
2728 for(
size_t pin = 0;
pin < connector.
gates[0].connectorPins.size(); ++
pin )
2751 BOOST_CHECK_NE( controller7Record11214.
Value(), controller7Record12125.
Value() );
2757 std::set<uint64_t> fieldIds;
2759 for(
size_t ordinal = 0; ordinal < definition.
fields.size(); ++ordinal )
2795 for(
size_t i = 0; i < partType.
fields.size(); ++i )
2806 PADS_SCH_MODEL repeated = parser.
Parse( loadBinaryFixture(
"fields.sch" ), wxS(
"fields.sch" ) );
2816 parser.
Parse( loadBinaryFixture(
"placement_transform.sch" ), wxS(
"placement_transform.sch" ) );
2819 const std::array<wxString, 5> references = { wxS(
"R1" ), wxS(
"R2" ), wxS(
"R3" ), wxS(
"R4" ), wxS(
"R5" ) };
2823 const std::array<int, 5> angles = { 0, 900, 0, 900, 900 };
2824 const std::array<bool, 5> mirrored = {
false,
false,
true,
true,
true };
2825 const std::array<uint16_t, 5> mirrorFlags = { 0, 0, 3, 3, 2 };
2826 const std::array<std::pair<uint16_t, int>, 4> orthogonalAngles = {
2827 std::pair<uint16_t, int>{ 0, 0 }, { 900, 900 }, { 1800, 1800 }, { 2700, 2700 }
2830 for(
const auto& [raw,
normalized] : orthogonalAngles )
2832 std::vector<uint8_t> transform = loadBinaryFixture(
"placement_transform.sch" );
2833 writeU16( transform, sheetControllerOffset( transform, 15 ) + 0x24, raw );
2837 wxString::Format( wxS(
"%u" ), raw ) );
2840 for(
size_t i = 0; i <
model.placements.size(); ++i )
2850 wxString::Format( wxS(
"%d" ), angles[i] ) );
2852 wxString::Format( wxS(
"%u" ), mirrorFlags[i] ) );
2853 auto rawAngle = std::ranges::find_if( placement.
properties,
2856 return aProperty.name.text == wxS(
"raw_angle" );
2858 auto rawMirror = std::ranges::find_if( placement.
properties,
2861 return aProperty.name.text == wxS(
"raw_mirror" );
2875 BOOST_CHECK_GE( placement.
fields.size(), 3 );
2890 auto placement = std::ranges::find_if( aModel.
placements,
2893 return aPlacement.reference.text == aReference;
2899 PADS_SCH_MODEL multi = parser.
Parse( loadBinaryFixture(
"multigate.sch" ), wxS(
"multigate.sch" ) );
2900 const MODEL_PLACEMENT& gateA = placementNamed( multi, wxS(
"U3-A" ) );
2901 const MODEL_PLACEMENT& gateB = placementNamed( multi, wxS(
"U3-B" ) );
2908 PADS_SCH_MODEL connectors = parser.
Parse( loadBinaryFixture(
"connectors.sch" ), wxS(
"connectors.sch" ) );
2909 const MODEL_PLACEMENT& connector = placementNamed( connectors, wxS(
"P1-1" ) );
2911 BOOST_CHECK_GE( connector.
fields.size(), 4 );
2925 BOOST_REQUIRE_GE( placement.
fields.size(), 3 );
2951 auto attributeIndex = std::ranges::find_if( placement.
fields[2].properties,
2954 return aProperty.name.text == wxS(
"component_attribute_index" );
2961 for(
size_t i = 0; i < placement.
fields.size(); ++i )
2973 parser.
Parse( loadBinaryFixture(
"placement_transform.sch" ), wxS(
"duplicate-placement.sch" ) );
2978 return aError.What().Contains( wxS(
"duplicate placement ID" ) )
2979 && aError.What().Contains( wxS(
"controller 15" ) )
2980 && aError.What().Contains( wxS(
"first at" ) );
2983 std::vector<uint8_t> unresolvedPart = loadBinaryFixture(
"placement_transform.sch" );
2984 writeU16( unresolvedPart, sheetControllerOffset( unresolvedPart, 15 ) + 0x42, 20 );
2985 BOOST_CHECK_EXCEPTION( parser.
Parse( unresolvedPart, wxS(
"placement-part.sch" ) ),
IO_ERROR,
2988 return aError.
What().Contains( wxS(
"targets definition object class" ) )
2989 && aError.
What().Contains( wxS(
"controller 15" ) );
2992 std::vector<uint8_t> wrongGroup = loadBinaryFixture(
"placement_transform.sch" );
2993 writeU32( wrongGroup, sheetControllerOffset( wrongGroup, 15 ) + 0x1C, 0xFFFFFFFF );
2994 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongGroup, wxS(
"placement-group.sch" ) ),
IO_ERROR,
2997 return aError.
What().Contains( wxS(
"component-group handle" ) );
3000 std::vector<uint8_t> wrongDecal = loadBinaryFixture(
"placement_transform.sch" );
3001 writeU16( wrongDecal, sheetControllerOffset( wrongDecal, 15 ) + 0x44, 0 );
3002 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongDecal, wxS(
"placement-decal.sch" ) ),
IO_ERROR,
3005 return aError.
What().Contains( wxS(
"different object classes" ) );
3008 std::vector<uint8_t> wrongGate = loadBinaryFixture(
"multigate.sch" );
3009 writeU16( wrongGate, sheetControllerOffset( wrongGate, 15 ) + 136 + 0x4A, 7 );
3010 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongGate, wxS(
"placement-gate.sch" ) ),
IO_ERROR,
3013 return aError.
What().Contains( wxS(
"gate handle targets definition object class" ) );
3016 std::vector<uint8_t> wrongPin = loadBinaryFixture(
"placement_transform.sch" );
3017 writeU16( wrongPin, sheetControllerOffset( wrongPin, 16 ) + 4, 0xFFFF );
3018 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongPin, wxS(
"placement-pin.sch" ) ),
IO_ERROR,
3021 return aError.
What().Contains( wxS(
"placed-pin handle" ) );
3024 std::vector<uint8_t> wrongField = loadBinaryFixture(
"fields.sch" );
3025 BOOST_REQUIRE_GT( readU32( wrongField, 0x20 + 7 * 28 + 8 ), 10 );
3026 BOOST_REQUIRE_LE( readU32( wrongField, 0x20 + 19 * 28 + 8 ), 10 );
3027 writeU16( wrongField, sheetControllerOffset( wrongField, 17 ), 10 );
3028 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongField, wxS(
"placement-field.sch" ) ),
IO_ERROR,
3031 return aError.
What().Contains( wxS(
"placement font handle" ) );
3034 std::vector<uint8_t> wrongAttribute = loadBinaryFixture(
"fields.sch" );
3035 writeU16( wrongAttribute, sheetControllerOffset( wrongAttribute, 17 ) + 16, 0xFFFE );
3036 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongAttribute, wxS(
"placement-field-attribute.sch" ) ),
IO_ERROR,
3039 return aError.
What().Contains( wxS(
"attribute index leaves component group" ) )
3040 && aError.
What().Contains( wxS(
"controller 17" ) );
3044 parser.
Parse( loadBinaryFixture(
"placement_transform.sch" ), wxS(
"placement-sheet.sch" ) );
3045 const uint32_t wrongClassSheet = wrongSheet.
definitions.back().id.Value();
3049 return aSheet.id.Value() == wrongClassSheet;
3051 wrongSheet.placements[0].sheet = {
SHEET_ID( wrongClassSheet ), wrongSheet.placements[0].source };
3052 BOOST_CHECK_EXCEPTION( wrongSheet.ValidateOrThrow(),
IO_ERROR,
3055 return aError.What().Contains( wxS(
"unresolved placement sheet reference" ) );
3058 std::vector<uint8_t> unknownTransform = loadBinaryFixture(
"placement_transform.sch" );
3059 writeU16( unknownTransform, sheetControllerOffset( unknownTransform, 15 ) + 0x24, 123 );
3060 writeU16( unknownTransform, sheetControllerOffset( unknownTransform, 15 ) + 0x26, 9 );
3067 return aDiagnostic.message.Contains(
3068 wxS(
"unknown placement transform" ) );
3072 std::vector<uint8_t> boundaryTransform = loadBinaryFixture(
"placement_transform.sch" );
3073 writeU16( boundaryTransform, sheetControllerOffset( boundaryTransform, 15 ) + 0x24, 3600 );
3074 writeU16( boundaryTransform, sheetControllerOffset( boundaryTransform, 15 ) + 0x26, 1 );
3075 PADS_SCH_MODEL boundary = parser.
Parse( boundaryTransform, wxS(
"placement-transform-boundary.sch" ) );
3083 return aDiagnostic.message.Contains(
3084 wxS(
"unknown placement transform" ) );
3094 wxS(
"placement_transform_options.sch" ) );
3098 const std::array<int, 4> angles = { 0, 900, 1800, 2700 };
3100 for(
size_t i = 0; i <
model.placements.size(); ++i )
3103 const uint16_t expectedMirror = i / angles.size();
3110 wxString::Format( wxS(
"%d" ), angles[i % angles.size()] ) );
3112 wxString::Format( wxS(
"%u" ), expectedMirror ) );
3120 const std::array<std::string, 7> fixtures = {
3121 "placement_transform",
"placement_transform_options",
"fields",
"connectors",
3122 "multigate",
"field_justification",
"pin_justification"
3125 for(
const std::string& fixture : fixtures )
3128 binaryParser.
Parse( loadBinaryFixture( fixture +
".sch" ), wxString::FromUTF8( fixture +
".sch" ) );
3133 for(
size_t placementIndex = 0; placementIndex < binary.
placements.size(); ++placementIndex )
3143 auto part = std::ranges::find_if( binary.
partTypes,
3146 return aPart.id == binaryPlacement.partType.id;
3151 auto gate = std::ranges::find_if( part->gates,
3154 return aGate.id == binaryPlacement.gate->id;
3158 auto definition = std::ranges::find_if( binary.
definitions,
3161 return aDefinition.id == binaryPlacement.definition.id;
3166 BOOST_REQUIRE_GE( binaryPlacement.
fields.size(), asciiPlacement.
attributes.size() );
3172 for(
size_t pinIndex = 0; pinIndex < binaryPlacement.
pins.size(); ++pinIndex )
3181 for(
size_t fieldIndex = 0; fieldIndex < asciiPlacement.
attributes.size(); ++fieldIndex )
3186 const wxString asciiValue = fieldIndex == 0 ? wxString::FromUTF8( asciiPlacement.
reference )
3187 : fieldIndex == 1 ? wxString::FromUTF8( asciiPlacement.
part_type )
3188 : wxString::FromUTF8( asciiField.
value );
3195 const bool expectedVisible = fieldIndex == 0 ? binaryPlacement.
referenceVisible
3201 wxString::FromUTF8( asciiField.
font_name ).StartsWith( wxS(
"Bold " ) ) );
3203 wxString::FromUTF8( asciiField.
font_name ).StartsWith( wxS(
"Italic " ) ) );
3206 == canonicalHorizontalJustification( asciiField.
justification ).value );
3208 == canonicalVerticalJustification( asciiField.
justification ).value );
3210 if( fieldIndex >= 2 )
3213 wxString::Format( wxS(
"%d" ), asciiField.
visibility ) );
3214 const wxString expectedAttributeIndex = fixture ==
"fields" || fixture ==
"field_justification"
3215 || fixture ==
"placement_transform_options"
3219 expectedAttributeIndex );
3231 parser.
Parse( loadBinaryFixture(
"connectivity_topology.sch" ), wxS(
"connectivity_topology.sch" ) );
3265 parser.
Parse( loadBinaryFixture(
"connectivity_topology.sch" ), wxS(
"connectivity_topology.sch" ) );
3273 auto global = std::ranges::find_if(
model.labels,
3276 return aLabel.kind == MODEL_LABEL_KIND::GLOBAL;
3285 parser.
Parse( loadBinaryFixture(
"multisheet_connectivity.sch" ), wxS(
"multisheet_connectivity.sch" ) );
3289 return aLabel.kind == MODEL_LABEL_KIND::GLOBAL
3290 && aLabel.text.text == wxS(
"CROSS_SHEET" );
3293 std::vector<const MODEL_LABEL*> crossSheetLabels;
3298 crossSheetLabels.push_back( &label );
3302 std::ranges::sort( crossSheetLabels,
3320 parser.
Parse( loadBinaryFixture(
"connectivity_topology.sch" ), wxS(
"connectivity_topology.sch" ) );
3355 return aGraphic.kind == MODEL_GRAPHIC_KIND::LINE;
3358 BOOST_CHECK_GE( std::ranges::count_if(
model.worksheets[0].graphics,
3361 return aGraphic.kind == MODEL_GRAPHIC_KIND::POLYLINE;
3367 return aGraphic.kind == MODEL_GRAPHIC_KIND::TEXT;
3370 auto titleText = std::ranges::find_if(
model.worksheets[0].graphics,
3373 return aGraphic.kind == MODEL_GRAPHIC_KIND::TEXT
3374 && aGraphic.text.text == wxS(
"TITLE:" );
3379 auto titleGroup = std::ranges::find_if( titleText->properties,
3382 return aProperty.name.text == wxS(
"page_graphic_group" );
3385 const uint16_t titleTextCount =
3386 readU16( loadBinaryFixture(
"page_graphics.sch" ), titleGroup->source.absoluteOffset + 64 );
3387 BOOST_REQUIRE_GT( titleTextCount, 1u );
3389 std::vector<uint8_t> repeatedPredecessor = loadBinaryFixture(
"page_graphics.sch" );
3390 const uint16_t lastTextRecord = readU16( repeatedPredecessor, titleGroup->source.absoluteOffset + 66 );
3391 writeU16( repeatedPredecessor, sheetControllerOffset( repeatedPredecessor, 1 ) + lastTextRecord * 32 + 24,
3393 BOOST_CHECK_EXCEPTION( parser.
Parse( repeatedPredecessor, wxS(
"page-text-cycle.sch" ) ),
IO_ERROR,
3396 return aError.
What().Contains(
3397 wxS(
"page-text predecessor repeats controller 1 record" ) );
3400 std::vector<uint8_t> noncontiguousPredecessor = loadBinaryFixture(
"page_graphics.sch" );
3401 const size_t textController = sheetControllerOffset( noncontiguousPredecessor, 1 );
3402 const uint16_t predecessor1 = readU16( noncontiguousPredecessor, textController + lastTextRecord * 32 + 24 );
3403 const uint16_t predecessor2 = readU16( noncontiguousPredecessor, textController + predecessor1 * 32 + 24 );
3404 const uint16_t predecessor3 = readU16( noncontiguousPredecessor, textController + predecessor2 * 32 + 24 );
3405 writeU16( noncontiguousPredecessor, textController + lastTextRecord * 32 + 24, predecessor2 );
3406 writeU16( noncontiguousPredecessor, textController + predecessor2 * 32 + 24, predecessor1 );
3407 writeU16( noncontiguousPredecessor, textController + predecessor1 * 32 + 24, predecessor3 );
3408 PADS_SCH_MODEL noncontiguous = parser.
Parse( noncontiguousPredecessor, wxS(
"page-text-noncontiguous.sch" ) );
3409 std::vector<size_t> recoveredRecords;
3416 && propertyValue( graphic.
properties, wxS(
"page_graphic_group" ) ) == titleGroup->value.text )
3423 BOOST_CHECK_EQUAL( recoveredRecords[recoveredRecords.size() - 3], predecessor1 );
3424 BOOST_CHECK_EQUAL( recoveredRecords[recoveredRecords.size() - 2], predecessor2 );
3427 std::vector<const MODEL_PAGE_GRAPHIC*> custom;
3431 if( propertyValue( graphic.graphic.
properties, wxS(
"page_graphic_group" ) ) == wxS(
"BATCHB_PAGE_GRAPHICS" ) )
3433 custom.push_back( &graphic );
3440 return std::ranges::find_if( custom,
3453 std::vector<uint8_t> unprovedLineStyle = loadBinaryFixture(
"page_graphics.sch" );
3454 unprovedLineStyle[( *line )->graphic.source.absoluteOffset + 1] = 2;
3455 PADS_SCH_MODEL unprovedStyleModel = parser.
Parse( unprovedLineStyle, wxS(
"unproved-line-style.sch" ) );
3456 auto unprovedStyleGraphic = std::ranges::find_if( unprovedStyleModel.
graphics,
3459 return aGraphic.graphic.source.recordIndex
3460 == ( *line )->graphic.source.recordIndex;
3467 return aDiagnostic.message.Contains(
3468 wxS(
"page graphic line style 2" ) );
3485 BOOST_CHECK_EQUAL( ( *text )->graphic.presentation.font.text, wxS(
"Verdana" ) );
3490 auto pageRecords = []( std::vector<CANONICAL_SEMANTIC_RECORD> aRecords )
3492 std::erase_if( aRecords,
3493 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
3495 auto group = aRecord.properties.find(
"page_graphic_group" );
3496 return aRecord.kind != CANONICAL_KIND::GRAPHIC ||
group == aRecord.properties.end()
3497 ||
group->second.value != CANONICAL_VALUE( std::string(
"BATCHB_PAGE_GRAPHICS" ) );
3501 auto expectedPage = pageRecords( normalizeAsciiModel( ascii ) );
3502 auto actualPage = pageRecords( normalizeBinaryModel(
model ) );
3503 BOOST_CHECK( snapshotsMatch( expectedPage, actualPage,
3506 std::vector<uint8_t> privateStroke = loadBinaryFixture(
"page_graphics.sch" );
3507 const size_t privatePiece = sheetControllerOffset( privateStroke, 4 ) + 81 * 6;
3508 writeU16( privateStroke, privatePiece + 4, 0xEF03 );
3509 PADS_SCH_MODEL preservedStroke = parser.
Parse( privateStroke, wxS(
"private-stroke.sch" ) );
3510 auto privateGraphic = std::ranges::find_if( preservedStroke.
graphics,
3513 return aGraphic.graphic.source.controller == 4
3514 && aGraphic.graphic.source.recordIndex == 81;
3518 auto rawStroke = std::ranges::find_if( privateGraphic->graphic.properties,
3521 return aProperty.name.text == wxS(
"unsupported_graphic_stroke_width" );
3523 BOOST_REQUIRE( rawStroke != privateGraphic->graphic.properties.end() );
3530 BOOST_CHECK_EQUAL( propertyValue( privateGraphic->graphic.properties, wxS(
"preserved_graphic_presentation" ) ),
3535 return aDiagnostic.source == rawStroke->source && aDiagnostic.property
3536 && aDiagnostic.property->name == rawStroke->name.text
3537 && aDiagnostic.property->disposition == rawStroke->disposition;
3546 const PADS_SCH_MODEL minimal = parser.
Parse( loadBinaryFixture(
"minimal_v13.sch" ), wxS(
"minimal_v13.sch" ) );
3553 const PADS_SCH_MODEL page = parser.
Parse( loadBinaryFixture(
"page_graphics.sch" ), wxS(
"page_graphics.sch" ) );
3561 return propertyValue( aGraphic.graphic.properties,
3562 wxS(
"page_graphic_group" ) )
3563 == wxS(
"BATCHB_PAGE_GRAPHICS" );
3566 std::vector<uint8_t> distinct = loadBinaryFixture(
"page_graphics.sch" );
3567 const std::string duplicateName =
"BATCHB_SIZEB";
3568 auto duplicateRecord = std::search( distinct.begin(), distinct.end(), duplicateName.begin(), duplicateName.end() );
3570 const size_t duplicateOffset = std::distance( distinct.begin(), duplicateRecord );
3571 const size_t firstVertex = readU32( distinct, duplicateOffset + 0x34 );
3572 const size_t vertexOffset = sheetControllerOffset( distinct, 5 ) + firstVertex * 8;
3573 writeU16( distinct, vertexOffset, readU16( distinct, vertexOffset ) + 2 );
3575 const PADS_SCH_MODEL distinctPage = parser.
Parse( distinct, wxS(
"distinct-page-graphics.sch" ) );
3582 return propertyValue( aGraphic.graphic.properties,
3583 wxS(
"page_graphic_group" ) )
3584 == wxS(
"BATCHB_SIZEB" );
3590 return aDiagnostic.message.Contains(
3591 wxS(
"distinct worksheet layout preserved" ) );
3600 std::vector<uint8_t> wrongEndpoint = loadBinaryFixture(
"connectivity_topology.sch" );
3601 const size_t connection = sheetControllerOffset( wrongEndpoint, 21 );
3602 writeU16( wrongEndpoint, connection + 12, 0x1000 );
3603 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongEndpoint, wxS(
"wrong-endpoint.sch" ) ),
IO_ERROR,
3606 return aError.
What().Contains( wxS(
"controller 21" ) )
3607 && aError.
What().Contains( wxS(
"wrong endpoint object class" ) );
3610 std::vector<uint8_t> unresolvedEndpoint = loadBinaryFixture(
"connectivity_topology.sch" );
3611 writeU16( unresolvedEndpoint, connection + 12, 0x2FFF );
3612 BOOST_CHECK_EXCEPTION( parser.
Parse( unresolvedEndpoint, wxS(
"unresolved-endpoint.sch" ) ),
IO_ERROR,
3615 return aError.
What().Contains( wxS(
"controller 21" ) )
3616 && aError.
What().Contains( wxS(
"unresolved off-page endpoint" ) );
3619 std::vector<uint8_t> unresolvedPlacement = loadBinaryFixture(
"minimal_v13.sch" );
3620 const size_t minimalConnection = sheetControllerOffset( unresolvedPlacement, 21 );
3622 writeU16( unresolvedPlacement, minimalConnection + 12, 0x0FFF );
3623 BOOST_CHECK_EXCEPTION( parser.
Parse( unresolvedPlacement, wxS(
"unresolved-placement.sch" ) ),
IO_ERROR,
3626 return aError.
What().Contains( wxS(
"controller 21" ) )
3627 && aError.
What().Contains( wxS(
"unresolved placement endpoint" ) );
3630 std::vector<uint8_t> duplicateMembership = loadBinaryFixture(
"connectivity_topology.sch" );
3631 const size_t globalNets = outerControllerOffset( duplicateMembership, 8 );
3632 writeU32( duplicateMembership, globalNets + 2 * 88 + 4, 1 );
3633 BOOST_CHECK_EXCEPTION( parser.
Parse( duplicateMembership, wxS(
"duplicate-membership.sch" ) ),
IO_ERROR,
3636 return aError.
What().Contains( wxS(
"controller 8" ) )
3637 && aError.
What().Contains( wxS(
"duplicate net sheet-membership" ) );
3640 std::vector<uint8_t> wrongNetClass = loadBinaryFixture(
"connectivity_topology.sch" );
3641 const size_t wrongNetConnection = sheetControllerOffset( wrongNetClass, 21 );
3642 writeU32( wrongNetClass, wrongNetConnection + 8, 0 );
3643 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongNetClass, wxS(
"wrong-net-class.sch" ) ),
IO_ERROR,
3646 return aError.
What().Contains( wxS(
"controller 21" ) )
3647 && aError.
What().Contains( wxS(
"wrong or unresolved object class" ) );
3650 std::vector<uint8_t> wrongBusClass = loadBinaryFixture(
"connectivity_topology.sch" );
3651 const size_t wrongBus = sheetControllerOffset( wrongBusClass, 18 );
3652 writeU32( wrongBusClass, wrongBus + 8, 1 );
3653 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongBusClass, wxS(
"wrong-bus-class.sch" ) ),
IO_ERROR,
3656 return aError.
What().Contains( wxS(
"controller 18" ) )
3657 && aError.
What().Contains( wxS(
"wrong or unresolved object class" ) );
3660 std::vector<uint8_t> wrongSheet = loadBinaryFixture(
"multisheet_connectivity.sch" );
3661 const size_t sheetMembership = outerControllerOffset( wrongSheet, 4 );
3662 writeU16( wrongSheet, sheetMembership + 2, 2 );
3663 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongSheet, wxS(
"wrong-net-sheet.sch" ) ),
IO_ERROR,
3666 return aError.
What().Contains( wxS(
"controller 8" ) )
3667 && aError.
What().Contains( wxS(
"wrong sheet object class" ) );
3670 std::vector<uint8_t> busCycle = loadBinaryFixture(
"connectivity_topology.sch" );
3671 const size_t bus = sheetControllerOffset( busCycle, 18 );
3672 const size_t offpage = sheetControllerOffset( busCycle, 20 );
3673 const uint16_t tailHandle = readU16( busCycle, bus + 24 );
3675 const uint16_t tailRecord = tailHandle & 0x0FFF;
3676 writeU16( busCycle, offpage + tailRecord * 32 + 4, tailHandle );
3677 BOOST_CHECK_EXCEPTION( parser.
Parse( busCycle, wxS(
"bus-entry-cycle.sch" ) ),
IO_ERROR,
3680 return aError.
What().Contains( wxS(
"controller 18" ) )
3681 && aError.
What().Contains( wxS(
"cyclic bus-entry" ) );
3684 std::vector<uint8_t> unresolvedLabelConnection = loadBinaryFixture(
"connectivity_topology.sch" );
3685 const size_t label = sheetControllerOffset( unresolvedLabelConnection, 20 );
3686 writeU16( unresolvedLabelConnection, label + 8, 0xFFFF );
3687 BOOST_CHECK_EXCEPTION( parser.
Parse( unresolvedLabelConnection, wxS(
"unresolved-label-connection.sch" ) ),
3691 return aError.
What().Contains( wxS(
"controller 20" ) )
3692 && aError.
What().Contains( wxS(
"off-page net handle leaves controller 21" ) );
3695 std::vector<uint8_t> wrongJunctionOwner = loadBinaryFixture(
"connectivity_topology.sch" );
3696 const size_t junction = sheetControllerOffset( wrongJunctionOwner, 19 );
3697 const uint16_t junctionOwner = readU16( wrongJunctionOwner, junction + 8 );
3698 BOOST_REQUIRE_GT( sheetControllerCount( wrongJunctionOwner, 21 ), 1 );
3699 writeU16( wrongJunctionOwner, junction + 8, junctionOwner == 0 ? 1 : 0 );
3700 const wxString junctionOwnerOffset =
3701 wxString::Format( wxS(
"offset 0x%llX" ),
static_cast<unsigned long long>( junction + 8 ) );
3702 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongJunctionOwner, wxS(
"wrong-junction-owner.sch" ) ),
IO_ERROR,
3705 return aError.
What().Contains( wxS(
"controller 19" ) )
3706 && aError.
What().Contains( wxS(
"does not point back" ) )
3707 && aError.
What().Contains( junctionOwnerOffset );
3710 std::vector<uint8_t> crossNetJunction = loadBinaryFixture(
"connectivity_topology.sch" );
3711 const size_t crossNetJunctions = sheetControllerOffset( crossNetJunction, 19 );
3712 const size_t crossNetConnections = sheetControllerOffset( crossNetJunction, 21 );
3713 const uint16_t tiedDotHandle = 0x3000;
3714 const uint16_t tiedDotOwner = readU16( crossNetJunction, crossNetJunctions + 8 );
3715 size_t sharedConnection = std::numeric_limits<size_t>::max();
3716 uint32_t differentNet = std::numeric_limits<uint32_t>::max();
3717 const uint32_t ownerNet = readU32( crossNetJunction, crossNetConnections + tiedDotOwner * 40 + 8 );
3719 for(
size_t record = 0; record < sheetControllerCount( crossNetJunction, 21 ); ++record )
3721 const size_t offset = crossNetConnections + record * 40;
3723 if( record != tiedDotOwner
3724 && ( readU16( crossNetJunction, offset + 12 ) == tiedDotHandle
3725 || readU16( crossNetJunction, offset + 14 ) == tiedDotHandle ) )
3727 sharedConnection = record;
3730 if( readU32( crossNetJunction, offset + 8 ) != ownerNet )
3731 differentNet = readU32( crossNetJunction, offset + 8 );
3734 BOOST_REQUIRE_NE( sharedConnection, std::numeric_limits<size_t>::max() );
3735 BOOST_REQUIRE_NE( differentNet, std::numeric_limits<uint32_t>::max() );
3736 writeU32( crossNetJunction, crossNetConnections + sharedConnection * 40 + 8, differentNet );
3737 const wxString crossNetOffset =
3738 wxString::Format( wxS(
"offset 0x%llX" ),
static_cast<unsigned long long>( crossNetJunctions + 8 ) );
3739 BOOST_CHECK_EXCEPTION( parser.
Parse( crossNetJunction, wxS(
"cross-net-junction.sch" ) ),
IO_ERROR,
3742 return aError.
What().Contains( wxS(
"controller 19" ) )
3743 && aError.
What().Contains( wxS(
"shared across different nets" ) )
3744 && aError.
What().Contains( crossNetOffset );
3747 std::vector<uint8_t> wrongOffpageOwner = loadBinaryFixture(
"connectivity_topology.sch" );
3748 const size_t offpageOwner = sheetControllerOffset( wrongOffpageOwner, 20 );
3749 const uint16_t connectionOwner = readU16( wrongOffpageOwner, offpageOwner + 8 );
3750 writeU16( wrongOffpageOwner, offpageOwner + 8, connectionOwner == 0 ? 1 : 0 );
3751 const wxString offpageOwnerOffset =
3752 wxString::Format( wxS(
"offset 0x%llX" ),
static_cast<unsigned long long>( offpageOwner + 8 ) );
3753 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongOffpageOwner, wxS(
"wrong-offpage-owner.sch" ) ),
IO_ERROR,
3756 return aError.
What().Contains( wxS(
"controller 20" ) )
3757 && aError.
What().Contains( wxS(
"does not point back" ) )
3758 && aError.
What().Contains( offpageOwnerOffset );
3761 std::vector<uint8_t> crossNetOffpage = loadBinaryFixture(
"connectivity_topology.sch" );
3762 const size_t crossNetOffpages = sheetControllerOffset( crossNetOffpage, 20 );
3763 const size_t crossNetOffpageConnections = sheetControllerOffset( crossNetOffpage, 21 );
3764 const size_t crossNetVertices = sheetControllerOffset( crossNetOffpage, 22 );
3765 const uint16_t offpageConnection = readU16( crossNetOffpage, crossNetOffpages + 8 );
3766 const uint32_t offpageNet = readU32( crossNetOffpage, crossNetOffpageConnections + offpageConnection * 40 + 8 );
3767 size_t foreignConnection = std::numeric_limits<size_t>::max();
3769 for(
size_t record = 0; record < sheetControllerCount( crossNetOffpage, 21 ); ++record )
3771 if( readU32( crossNetOffpage, crossNetOffpageConnections + record * 40 + 8 ) != offpageNet )
3773 foreignConnection = record;
3778 BOOST_REQUIRE_NE( foreignConnection, std::numeric_limits<size_t>::max() );
3779 const size_t foreignOffset = crossNetOffpageConnections + foreignConnection * 40;
3780 const size_t firstVertex = crossNetVertices + readU32( crossNetOffpage, foreignOffset + 4 ) * 8;
3781 writeU16( crossNetOffpage, foreignOffset + 12, 0x2000 );
3782 writeU16( crossNetOffpage, firstVertex + 4, readU16( crossNetOffpage, crossNetOffpages + 22 ) );
3783 writeU16( crossNetOffpage, firstVertex + 6, readU16( crossNetOffpage, crossNetOffpages + 24 ) );
3784 BOOST_CHECK_EXCEPTION( parser.
Parse( crossNetOffpage, wxS(
"cross-net-offpage.sch" ) ),
IO_ERROR,
3787 return aError.
What().Contains( wxS(
"controller 20" ) )
3788 && aError.
What().Contains( wxS(
"shared across different nets" ) );
3796 std::vector<CANONICAL_SEMANTIC_RECORD> allActual;
3798 for(
const std::string& fixture :
3799 {
"minimal_v13",
"placement_transform",
"fields",
"connectors",
"text_encoding",
"page_graphics",
3800 "connectivity_topology",
"multisheet_connectivity",
"symbol_primitives",
"pin_styles",
"multigate" } )
3803 binaryParser.
Parse( loadBinaryFixture( fixture +
".sch" ), wxString::FromUTF8( fixture +
".sch" ) );
3807 auto task10 = []( std::vector<CANONICAL_SEMANTIC_RECORD> aRecords )
3809 std::erase_if( aRecords,
3810 [](
const CANONICAL_SEMANTIC_RECORD& aRecord )
3812 return aRecord.kind != CANONICAL_KIND::NET && aRecord.kind != CANONICAL_KIND::CONNECTION
3813 && aRecord.kind != CANONICAL_KIND::BUS
3814 && aRecord.kind != CANONICAL_KIND::BUS_ENTRY
3815 && aRecord.kind != CANONICAL_KIND::BUS_ALIAS
3816 && aRecord.kind != CANONICAL_KIND::BUS_MEMBER
3817 && aRecord.kind != CANONICAL_KIND::LABEL
3818 && aRecord.kind != CANONICAL_KIND::JUNCTION
3819 && ( aRecord.kind != CANONICAL_KIND::GRAPHIC
3820 || !aRecord.properties.contains(
"page_graphic_group" )
3821 || aRecord.properties.at(
"page_graphic_group" ).value
3822 != CANONICAL_VALUE( std::string(
"BATCHB_PAGE_GRAPHICS" ) ) );
3828 const SNAPSHOT_ALLOWLIST sourceProperties = {
3850 BOOST_REQUIRE_GE( connection.
vertices.size(), 2 );
3861 auto expected = task10( normalizeAsciiModel( ascii ) );
3862 auto actual = task10( normalizeBinaryModel( binary ) );
3864 allActual.insert( allActual.end(),
actual.begin(),
actual.end() );
3868 BOOST_CHECK( task10SourcePropertiesPresent( allActual ) );
3869 auto missingRawKind = allActual;
3871 auto label = std::ranges::find( missingRawKind, CANONICAL_KIND::LABEL, &CANONICAL_SEMANTIC_RECORD::kind );
3873 label->properties.erase(
"offpage_variant" );
3875 BOOST_CHECK( !task10SourcePropertiesPresent( missingRawKind ) );
3877 for(
const std::string& endpoint :
3878 {
"endpoint_0_raw_endpoint_handle",
"endpoint_1_raw_endpoint_handle",
"endpoint_0_raw_endpoint_relationship",
3879 "endpoint_1_raw_endpoint_relationship" } )
3881 auto missingEndpoint = allActual;
3883 std::ranges::find( missingEndpoint, CANONICAL_KIND::CONNECTION, &CANONICAL_SEMANTIC_RECORD::kind );
3885 connection->properties.erase( endpoint );
3886 BOOST_CHECK( !task10SourcePropertiesPresent( missingEndpoint ) );
3894 std::vector<uint8_t> wrongClass = loadBinaryFixture(
"symbol_primitives.sch" );
3895 size_t usedDecals = sheetControllerOffset( wrongClass, 7 );
3896 writeU32( wrongClass, usedDecals + 104 * 108 + 48, 8 );
3897 BOOST_CHECK_EXCEPTION( parser.
Parse( wrongClass, wxS(
"wrong-class.sch" ) ),
IO_ERROR,
3901 return message.Contains( wxS(
"wrong object class" ) )
3902 &&
message.Contains( wxS(
"controller 7" ) )
3903 &&
message.Contains( wxS(
"record 104" ) );
3906 std::vector<uint8_t> unresolved = loadBinaryFixture(
"multigate.sch" );
3907 size_t gates = sheetControllerOffset( unresolved, 10 );
3908 writeU16( unresolved, gates + 12, 0xFFFF );
3909 BOOST_CHECK_EXCEPTION( parser.
Parse( unresolved, wxS(
"unresolved.sch" ) ),
IO_ERROR,
3912 return aError.
What().Contains( wxS(
"unresolved symbol definition reference" ) );
3915 std::vector<uint8_t> badPinHandle = loadBinaryFixture(
"symbol_primitives.sch" );
3916 size_t terminals = sheetControllerOffset( badPinHandle, 8 );
3917 writeU16( badPinHandle, terminals + 8 * 26, 0xFFFE );
3918 BOOST_CHECK_EXCEPTION( parser.
Parse( badPinHandle, wxS(
"bad-pin-handle.sch" ) ),
IO_ERROR,
3921 return aError.
What().Contains( wxS(
"pin-decal handle" ) )
3922 && aError.
What().Contains( wxS(
"controller 8" ) );
3925 std::vector<uint8_t> gateCount = loadBinaryFixture(
"multigate.sch" );
3926 size_t partTypes = sheetControllerOffset( gateCount, 9 );
3927 writeU16( gateCount, partTypes + 76 + 68, 3 );
3928 BOOST_CHECK_EXCEPTION( parser.
Parse( gateCount, wxS(
"gate-count.sch" ) ),
IO_ERROR,
3931 return aError.
What().Contains( wxS(
"gate count" ) )
3932 && aError.
What().Contains( wxS(
"controller 9" ) );
3935 std::vector<uint8_t> fieldHandle = loadBinaryFixture(
"symbol_primitives.sch" );
3936 size_t fieldDecals = sheetControllerOffset( fieldHandle, 7 );
3937 writeU32( fieldHandle, fieldDecals + 104 * 108 + 52, 132 );
3938 BOOST_CHECK_EXCEPTION( parser.
Parse( fieldHandle, wxS(
"field-handle.sch" ) ),
IO_ERROR,
3941 return aError.
What().Contains( wxS(
"field" ) )
3942 && aError.
What().Contains( wxS(
"controller 7" ) );
3945 std::vector<uint8_t> alternateHandle = loadBinaryFixture(
"multigate.sch" );
3946 size_t alternateGates = sheetControllerOffset( alternateHandle, 10 );
3947 writeU16( alternateHandle, alternateGates + 2, 0xFFFE );
3948 BOOST_CHECK_EXCEPTION( parser.
Parse( alternateHandle, wxS(
"alternate-handle.sch" ) ),
IO_ERROR,
3951 return aError.
What().Contains( wxS(
"alternate symbol definition" ) )
3952 && aError.
What().Contains( wxS(
"controller 10" ) );
3955 std::vector<uint8_t> binaryCycle = loadBinaryFixture(
"multigate.sch" );
3956 const size_t cyclePartTypes = sheetControllerOffset( binaryCycle, 9 );
3957 const size_t cycleGates = sheetControllerOffset( binaryCycle, 10 );
3958 const uint32_t firstGateRecord = readU32( binaryCycle, cyclePartTypes + 76 + 44 );
3959 const uint16_t firstDefinition = readU16( binaryCycle, cycleGates + firstGateRecord * 12 );
3960 const uint16_t secondDefinition = readU16( binaryCycle, cycleGates + ( firstGateRecord + 1 ) * 12 );
3961 writeU16( binaryCycle, cycleGates + firstGateRecord * 12 + 2, secondDefinition );
3962 writeU16( binaryCycle, cycleGates + ( firstGateRecord + 1 ) * 12 + 2, firstDefinition );
3963 BOOST_CHECK_EXCEPTION( parser.
Parse( binaryCycle, wxS(
"definition-cycle.sch" ) ),
IO_ERROR,
3966 return aError.
What().Contains( wxS(
"cyclic symbol definition reference" ) )
3967 && aError.
What().Contains( wxS(
"controller 10" ) );
3970 std::vector<uint8_t> unknownSide = loadBinaryFixture(
"pin_styles.sch" );
3971 const size_t unknownSideTerminals = sheetControllerOffset( unknownSide, 8 );
3972 writeU16( unknownSide, unknownSideTerminals + 22, 8 );
3977 return aDiagnostic.message.Contains( wxS(
"terminal side" ) )
3978 && aDiagnostic.source.controller == 8
3979 && aDiagnostic.source.recordIndex == 0;
3982 std::vector<uint8_t> unknownLength = loadBinaryFixture(
"pin_styles.sch" );
3983 const PADS_SCH_MODEL unknownLengthBaseline = parser.
Parse( unknownLength, wxS(
"known-length.sch" ) );
3984 const size_t unknownLengthTerminalRecord =
static_cast<size_t>(
3985 itemNamed( unknownLengthBaseline.
definitions, wxS(
"BATCHB_PIN_STYLES" ) ).pins[0].source.recordIndex );
3986 const size_t unknownLengthTerminals = sheetControllerOffset( unknownLength, 8 );
3987 const uint16_t pinDecalHandle = readU16( unknownLength, unknownLengthTerminals + unknownLengthTerminalRecord * 26 );
3988 const size_t unknownLengthDecals = sheetControllerOffset( unknownLength, 7 );
3989 const uint32_t pinDecalDefinition = readU32( unknownLength, unknownLengthDecals + pinDecalHandle * 108 + 48 );
3990 const size_t unknownLengthDefinitions = sheetControllerOffset( unknownLength, 3 );
3991 const uint32_t pinDecalVertex = readU32( unknownLength, unknownLengthDefinitions + pinDecalDefinition * 80 + 0x34 );
3992 const uint32_t pinDecalVertexEnd =
3993 readU32( unknownLength, unknownLengthDefinitions + ( pinDecalDefinition + 1 ) * 80 + 0x34 );
3994 const size_t unknownLengthVertices = sheetControllerOffset( unknownLength, 5 );
3996 for( uint32_t vertex = pinDecalVertex; vertex < pinDecalVertexEnd; ++vertex )
3998 const size_t vertexOffset = unknownLengthVertices + vertex * 6;
4000 if( readU16( unknownLength, vertexOffset ) == 0 && readU16( unknownLength, vertexOffset + 2 ) == 0 )
4001 writeU16( unknownLength, vertexOffset, 1 );
4003 PADS_SCH_MODEL unknownLengthModel = parser.
Parse( unknownLength, wxS(
"unknown-length.sch" ) );
4005 itemNamed( unknownLengthModel.
definitions, wxS(
"BATCHB_PIN_STYLES" ) ).pins[0];
4010 return aProperty.name.text == wxS(
"pin_length" )
4011 && aProperty.disposition == PROPERTY_DISPOSITION::UNSUPPORTED;
4014 std::vector<uint8_t> pieceCount = loadBinaryFixture(
"symbol_primitives.sch" );
4015 size_t definitions = sheetControllerOffset( pieceCount, 3 );
4016 pieceCount[definitions + 14 * 80 + 43] = 1;
4017 BOOST_CHECK_EXCEPTION( parser.
Parse( pieceCount, wxS(
"piece-count.sch" ) ),
IO_ERROR,
4020 return aError.
What().Contains( wxS(
"graphic-piece counts" ) )
4021 && aError.
What().Contains( wxS(
"controller 3" ) );
4024 std::vector<uint8_t> ownership = loadBinaryFixture(
"symbol_primitives.sch" );
4025 size_t ownershipDefinitions = sheetControllerOffset( ownership, 3 );
4026 const size_t vertexPrefix = ownershipDefinitions + 14 * 80 + 0x34;
4027 writeU32( ownership, vertexPrefix, readU32( ownership, vertexPrefix ) + 1 );
4028 BOOST_CHECK_EXCEPTION( parser.
Parse( ownership, wxS(
"piece-ownership.sch" ) ),
IO_ERROR,
4031 return aError.
What().Contains( wxS(
"ownership mismatch" ) )
4032 && aError.
What().Contains( wxS(
"controller 3" ) );
4035 auto duplicateModel = [&]()
4037 return parser.
Parse( loadBinaryFixture(
"multigate.sch" ), wxS(
"duplicate-id.sch" ) );
4044 return aError.What().Contains( wxS(
"duplicate definition ID" ) );
4051 return aError.What().Contains( wxS(
"duplicate part type ID" ) );
4058 return aError.What().Contains( wxS(
"duplicate gate ID" ) );
4062 size_t pinOwnerIndex = &pinOwner - duplicatePin.
definitions.data();
4067 return aError.What().Contains( wxS(
"duplicate pin ID" ) );
4076 return aError.What().Contains( wxS(
"duplicate field ID" ) )
4077 && aError.What().Contains( wxS(
"first at" ) );
4080 std::vector<uint8_t> duplicateBinaryField = loadBinaryFixture(
"fields.sch" );
4081 const size_t duplicateFieldDecals = sheetControllerOffset( duplicateBinaryField, 7 );
4082 const uint32_t textCount = sheetControllerCount( duplicateBinaryField, 1 );
4083 std::vector<size_t> fieldRecords;
4085 for(
size_t record = 0; record < sheetControllerCount( duplicateBinaryField, 7 ); ++record )
4087 if( readU32( duplicateBinaryField, duplicateFieldDecals + record * 108 + 52 ) < textCount )
4088 fieldRecords.push_back( record );
4091 BOOST_REQUIRE_GE( fieldRecords.size(), 2 );
4092 writeU32( duplicateBinaryField, duplicateFieldDecals + fieldRecords[1] * 108 + 52,
4093 readU32( duplicateBinaryField, duplicateFieldDecals + fieldRecords[0] * 108 + 52 ) );
4094 BOOST_CHECK_EXCEPTION( parser.
Parse( duplicateBinaryField, wxS(
"duplicate-field.sch" ) ),
IO_ERROR,
4097 return aError.
What().Contains( wxS(
"duplicate field ID" ) )
4098 && aError.
What().Contains( wxS(
"controller 7" ) )
4099 && aError.
What().Contains( wxS(
"first at" ) );
4102 std::vector<uint8_t> connectorPinName = loadBinaryFixture(
"connectors.sch" );
4103 const size_t connectorParts = sheetControllerOffset( connectorPinName, 9 );
4104 const size_t connectorPins = sheetControllerOffset( connectorPinName, 11 );
4105 const uint32_t connectorPinStart = readU32( connectorPinName, connectorParts + 76 + 48 );
4106 writeU32( connectorPinName, connectorPins + connectorPinStart * 24, 0xFFFFFFFE );
4107 BOOST_CHECK_EXCEPTION( parser.
Parse( connectorPinName, wxS(
"connector-pin-name.sch" ) ),
IO_ERROR,
4110 return aError.
What().Contains( wxS(
"pin-name offset leaves controller 14" ) )
4111 && aError.
What().Contains( wxS(
"controller 11" ) );
4119 PADS_SCH_MODEL binary = binaryParser.
Parse( loadBinaryFixture(
"pin_styles.sch" ), wxS(
"pin_styles.sch" ) );
4124 auto asciiDefinition = std::ranges::find_if( asciiParser.
GetSymbolDefs(),
4127 return aDefinition.name ==
"BATCHB_PIN_STYLES";
4133 static_cast<int64_t
>( std::llround( asciiDefinition->pins[0].position.x * 2 ) ) );
4135 ( asciiDefinition->pins[4].inverted ? 1U : 0U ) | ( asciiDefinition->pins[4].clock ? 2U : 0U ) );
4139 for(
size_t i = 0; i < binaryDefinition.
graphics.size(); ++i )
4142 == canonicalGraphicType( asciiDefinition->graphics[i].type ) );
4144 std::llround( asciiDefinition->graphics[i].line_width * 2 ) );
4146 == canonicalFill( asciiDefinition->graphics[i].filled ) );
4158 == canonicalPinStyle( aAsciiPin.inverted, aAsciiPin.clock ) );
4182 aAsciiSymbol.h2 != 0 && ( aAsciiPin.p_flags & 128 ) == 0 );
4186 for(
size_t i = 0; i < binaryDefinition.
pins.size(); ++i )
4190 BOOST_CHECK( canonicalPinType( binaryDefinition.
pins[i].electricalType )
4191 == canonicalPinType( asciiGate.
pins[i].pin_type ) );
4192 checkPinPresentation( binaryDefinition.
pins[i], *asciiDefinition, asciiDefinition->pins[i] );
4196 binaryParser.
Parse( loadBinaryFixture(
"symbol_primitives.sch" ), wxS(
"symbol_primitives.sch" ) );
4201 itemNamed( primitiveBinary.
definitions, wxS(
"BATCHB_PRIMITIVES" ) );
4205 asciiPrimitive->
graphics.size() + asciiPrimitive->
texts.size() );
4207 for(
size_t graphic = 0; graphic < asciiPrimitive->
graphics.size(); ++graphic )
4210 == canonicalGraphicType( asciiPrimitive->
graphics[graphic] ) );
4212 std::llround( asciiPrimitive->
graphics[graphic].line_width * 2 ) );
4215 == canonicalFill( asciiPrimitive->
graphics[graphic].filled ) );
4217 asciiPrimitive->
graphics[graphic].points.size() );
4219 for(
size_t pointIndex = 0; pointIndex < asciiPrimitive->
graphics[graphic].points.size(); ++pointIndex )
4222 std::llround( asciiPrimitive->
graphics[graphic].points[pointIndex].coord.x * 2 ) );
4224 std::llround( asciiPrimitive->
graphics[graphic].points[pointIndex].coord.y * 2 ) );
4237 wxString::FromUTF8( canonicalAsciiFont( primitiveAscii.
GetParameters(), asciiPrimitive->
font1 ) ) );
4241 == canonicalHorizontalJustification( asciiPrimitive->
texts[0].justification ).value );
4243 == canonicalVerticalJustification( asciiPrimitive->
texts[0].justification ).value );
4245 PADS_SCH_MODEL fieldsBinary = binaryParser.
Parse( loadBinaryFixture(
"fields.sch" ), wxS(
"fields.sch" ) );
4253 for(
size_t field = 0; field < asciiFields->
attrs.size(); ++field )
4258 wxString::FromUTF8( asciiFields->
attrs[field].attr_name ) );
4261 std::llround( asciiFields->
attrs[field].position.x * 2 ) );
4263 std::llround( asciiFields->
attrs[field].position.y * 2 ) );
4266 asciiFields->
attrs[field].height * 2 );
4269 wxString::FromUTF8( canonicalAsciiFont( fieldsAscii.
GetParameters(),
4270 asciiFields->
attrs[field].font_name ) ) );
4272 canonicalJustification( fieldsDefinition.
fields[field].presentation.horizontalJustification ).value
4273 == canonicalHorizontalJustification( asciiFields->
attrs[field].justification ).value );
4275 canonicalVerticalJustification( fieldsDefinition.
fields[field].presentation.verticalJustification )
4277 == canonicalVerticalJustification( asciiFields->
attrs[field].justification ).value );
4284 for(
size_t field = 0; field < fieldsPart.
fields.size(); ++field )
4291 PADS_SCH_MODEL multiBinary = binaryParser.
Parse( loadBinaryFixture(
"multigate.sch" ), wxS(
"multigate.sch" ) );
4301 auto definition = std::ranges::find_if( aModel.
definitions,
4304 return aDefinition.id == aReference.id;
4307 return definition->name.text;
4315 auto pin = std::ranges::find_if( definition.
pins,
4318 return aPin.id == aReference.id;
4321 if(
pin != definition.
pins.end() )
4325 BOOST_FAIL(
"unresolved pin reference" );
4326 throw std::logic_error(
"unreachable" );
4329 for(
size_t gate = 0; gate < multiPart.
gates.size(); ++gate )
4332 wxString::FromUTF8( asciiMulti.
gates[gate].decal_names.front() ) );
4334 wxString::Format( wxS(
"%d" ), asciiMulti.
gates[gate].swap_flag ) );
4337 for(
size_t pin = 0;
pin < multiPart.
gates[gate].pins.size(); ++
pin )
4343 wxString::Format( wxS(
"%d" ), asciiMulti.
gates[gate].pins[
pin].swap_group ) );
4351 wxString::FromUTF8( asciiAlternates.
decal_names[0] ) );
4353 for(
size_t alternate = 0; alternate < alternatePart.
gates[0].alternateDefinitions.size(); ++alternate )
4355 BOOST_CHECK_EQUAL( definitionName( multiBinary, alternatePart.
gates[0].alternateDefinitions[alternate] ),
4356 wxString::FromUTF8( asciiAlternates.
decal_names[alternate + 1] ) );
4359 for(
size_t signal = 0; signal < multiPart.
signalPins.size(); ++signal )
4362 wxString::FromUTF8( asciiMulti.
sigpins[signal].pin_number ) );
4364 wxString::FromUTF8( asciiMulti.
sigpins[signal].net_name ) );
4368 binaryParser.
Parse( loadBinaryFixture(
"connectors.sch" ), wxS(
"connectors.sch" ) );
4375 for(
size_t member = 0; member < asciiConnector.
decal_names.size(); ++member )
4378 wxString::FromUTF8( asciiConnector.
decal_names[member] ) );
4381 const std::array<std::string, 11> pairedFixtures = {
"minimal_v13",
4382 "placement_transform",
4387 "connectivity_topology",
4388 "multisheet_connectivity",
4389 "symbol_primitives",
4393 for(
const std::string& fixture : pairedFixtures )
4396 binaryParser.
Parse( loadBinaryFixture( fixture +
".sch" ), wxString::FromUTF8( fixture ) );
4403 if( binarySymbol.
pins.empty() )
4410 for(
size_t pin = 0;
pin < binarySymbol.
pins.size(); ++
pin )
4413 << binarySymbol.
pins[
pin].presentationFlags <<
"/"
4414 << binarySymbol.
pins[
pin].visibilityAndNumberPresentationFlags )
4416 checkPinPresentation( binarySymbol.
pins[
pin], *asciiSymbol, asciiSymbol->
pins[
pin] );
4425 fixture +
": " + binaryPart.
name.
text.ToStdString() );
4427 if( asciiPart->second.gates.empty() )
4432 for(
size_t gate = 0; gate < binaryPart.
gates.size(); ++gate )
4447 wxString::FromUTF8( asciiGateForPart.
pins[
pin].pin_id ) );
4449 wxString::FromUTF8( asciiGateForPart.
pins[
pin].pin_name ) );
4451 == canonicalPinType( asciiGateForPart.
pins[
pin].pin_type ) );
4467 wxString::FromUTF8( asciiGateForPart.
pins[
pin].pin_id ) );
4469 wxString::FromUTF8( asciiGateForPart.
pins[
pin].pin_name ) );
4471 == canonicalPinType( asciiGateForPart.
pins[
pin].pin_type ) );
4482 static constexpr std::array<const char*, 6> fixtures = {
"terminal_justification_0_6",
4483 "terminal_justification_7_13",
4484 "terminal_justification_14_15",
4485 "terminal_justification_90_0_6",
4486 "terminal_justification_90_7_13",
4487 "terminal_justification_90_14_15" };
4491 for(
const char* fixture : fixtures )
4493 const std::string binaryName = std::string( fixture ) +
".sch";
4494 const std::string asciiName = std::string( fixture ) +
".txt";
4495 PADS_SCH_MODEL binary = binaryParser.
Parse( loadBinaryFixture( binaryName ), wxString::FromUTF8( binaryName ) );
4504 for(
size_t pin = 0;
pin < binaryDefinition.
pins.size(); ++
pin )
4522 const size_t justificationOffset =
model.texts.front().source.absoluteOffset + 18;
4524 struct VERTICAL_CASE
4542 std::vector<uint8_t>
bytes = loadBinaryFixture(
"text_encoding.sch" );
4557 std::vector<uint8_t>
bytes = loadBinaryFixture(
"text_encoding.sch" );
4561 writeU16(
bytes,
model.labels.front().source.absoluteOffset + 28, 0xFF00 );
4569 return aDiagnostic.property
4570 && aDiagnostic.property->name == wxS(
"offpage_mirror_flags" );
static std::optional< VECTOR2D > normalized(const VECTOR2D &aVec)
bool operator==(const wxAuiPaneInfo &aLhs, const wxAuiPaneInfo &aRhs)
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
virtual const wxString What() const
A composite of Problem() and Where()
Parser for PADS Logic ASCII schematic export files.
const std::vector< TEXT_ITEM > & GetTextItems() const
const std::vector< TIED_DOT > & GetTiedDots() const
const std::vector< OFF_PAGE_CONNECTOR > & GetOffPageConnectors() const
bool Parse(const std::string &aFileName)
const std::vector< SHEET_HEADER > & GetSheetHeaders() const
const std::vector< NETNAME_LABEL > & GetNetNameLabels() const
const std::vector< BUS_DEF > & GetBuses() const
const std::vector< SCH_SIGNAL > & GetSignals() const
const std::vector< LINES_ITEM > & GetLinesItems() const
const std::vector< SYMBOL_DEF > & GetSymbolDefs() const
const std::vector< PART_PLACEMENT > & GetPartPlacements() const
const std::map< std::string, PARTTYPE_DEF > & GetPartTypes() const
const SYMBOL_DEF * GetSymbolDef(const std::string &aName) const
const PARAMETERS & GetParameters() const
constexpr ValueType Value() const
constexpr bool IsValid() const
PADS_SCH_MODEL Parse(const std::vector< uint8_t > &aBytes, const wxString &aSourceName={}) const
static SOURCE_STRING DecodeString(const std::vector< uint8_t > &aBytes, uint32_t aCodePage, const SOURCE_PROVENANCE &aSource, std::vector< PARSER_DIAGNOSTIC > &aDiagnostics, const wxString &aRecordedCodePageName={})
static void RecordUnknownEnum(const wxString &aEnumName, uint32_t aValue, const SOURCE_PROVENANCE &aSource, std::vector< PARSER_DIAGNOSTIC > &aDiagnostics)
void Load(std::vector< uint8_t > aBytes)
const std::vector< SCH_SDB_OLE_ITEM > & OleItems() const
std::string utf8(const wxString &aText)
static bool empty(const wxTextEntryBase *aCtrl)
static std::string ToStdString(const wxString &aStr)
std::string GetEeschemaTestDataDir()
Get the configured location of Eeschema test data.
constexpr int64_t NormalizeCoordinate(int64_t aCoordinate)
CONTROLLER_REFERENCE< DEFINITION_ID > DEFINITION_REFERENCE
constexpr int NormalizeAngle(int aAngle)
CONTROLLER_ID< NET_ID_TAG > NET_ID
CONTROLLER_ID< DEFINITION_ID_TAG > DEFINITION_ID
CONTROLLER_REFERENCE< PLACEMENT_ID > PLACEMENT_REFERENCE
CONTROLLER_REFERENCE< SHEET_ID > SHEET_REFERENCE
CONTROLLER_ID< SHEET_ID_TAG > SHEET_ID
CONTROLLER_ID< PIN_ID_TAG > PIN_ID
CONTROLLER_ID< FIELD_ID_TAG, uint64_t > FIELD_ID
constexpr FIELD_ID MakeFieldId(FIELD_ID_DOMAIN aDomain, uint32_t aOwner, uint32_t aOrdinal)
CONTROLLER_ID< PART_TYPE_ID_TAG > PART_TYPE_ID
wxString FormatParserError(const SOURCE_PROVENANCE &aSource, const wxString &aMessage)
CONTROLLER_ID< PLACEMENT_ID_TAG > PLACEMENT_ID
CONTROLLER_ID< GATE_ID_TAG > GATE_ID
CONTROLLER_REFERENCE< NET_ID > NET_REFERENCE
CONTROLLER_REFERENCE< GATE_ID > GATE_REFERENCE
CONTROLLER_ID< BUS_ID_TAG > BUS_ID
@ SHEET
Joins names in one instance only.
@ BUS_MEMBER
Synthetic claim of a bus member slot, set by BindBundle().
EDA_ANGLE abs(const EDA_ANGLE &aAngle)
@ NET
This item represents a net.
std::vector< std::string > decal_names
std::vector< PARTTYPE_PIN > pins
std::map< std::string, std::string > fields
std::vector< GATE_DEF > gates
std::vector< SIGPIN > sigpins
std::string decal_name
CAEDECAL the placed gate draws, empty when unresolved.
std::vector< PART_ATTRIBUTE > attributes
std::vector< PIN_OVERRIDE > pin_overrides
std::vector< SYMBOL_GRAPHIC > graphics
std::vector< SYMBOL_PIN > pins
std::vector< CAEDECAL_ATTR > attrs
std::vector< SYMBOL_TEXT > texts
std::vector< GRAPHIC_POINT > points
int64_t coordinateUnitsPerMil
std::vector< SOURCE_PROPERTY > properties
std::vector< MODEL_BUS_ENTRY > entries
std::vector< SOURCE_STRING > aliases
std::vector< NET_REFERENCE > memberNets
std::vector< SOURCE_POINT > vertices
std::vector< MODEL_CONNECTION_ENDPOINT > endpoints
std::vector< SOURCE_POINT > vertices
MODEL_TEXT_PRESENTATION presentation
std::vector< SOURCE_PROPERTY > properties
std::vector< DEFINITION_REFERENCE > decalGroupMembers
std::vector< MODEL_CONNECTOR_PIN > connectorPins
std::vector< PIN_REFERENCE > pins
std::vector< MODEL_GATE_PIN > logicalPins
std::vector< SOURCE_PROPERTY > properties
MODEL_TEXT_PRESENTATION presentation
SOURCE_POINT arcBoundsStart
SOURCE_POINT arcBoundsEnd
MODEL_LINE_STYLE lineStyle
std::vector< SOURCE_POINT > points
std::vector< MODEL_CONNECTION > connections
std::vector< MODEL_SIGNAL_PIN > signalPins
std::vector< MODEL_FIELD > fields
std::vector< MODEL_GATE > gates
uint16_t numberOffsetJustification
MODEL_TEXT_PRESENTATION namePresentation
std::vector< SOURCE_PROPERTY > properties
uint16_t nameOffsetJustification
SOURCE_POINT numberOffset
uint16_t numberJustification
uint16_t visibilityAndNumberPresentationFlags
MODEL_TEXT_PRESENTATION numberPresentation
uint16_t nameJustification
PART_TYPE_REFERENCE partType
DEFINITION_REFERENCE definition
std::vector< PLACED_PIN_REFERENCE > pins
std::vector< SOURCE_PROPERTY > properties
std::vector< MODEL_FIELD > fields
std::optional< GATE_REFERENCE > gate
std::optional< SHEET_REFERENCE > parent
std::vector< SOURCE_PROPERTY > properties
std::vector< MODEL_FIELD > titleBlockFields
std::vector< MODEL_GRAPHIC > border
std::vector< MODEL_GRAPHIC > graphics
std::vector< MODEL_PIN_DEFINITION > pins
std::vector< MODEL_FIELD > fields
MODEL_JUSTIFICATION verticalJustification
MODEL_JUSTIFICATION horizontalJustification
std::vector< MODEL_GRAPHIC > graphics
std::vector< MODEL_NET > nets
std::vector< MODEL_SYMBOL_DEFINITION > definitions
std::vector< MODEL_JUNCTION > junctions
void ValidateOrThrow() const
std::vector< MODEL_PAGE_GRAPHIC > graphics
std::vector< MODEL_WORKSHEET > worksheets
std::vector< MODEL_BUS > buses
std::vector< MODEL_LABEL > labels
std::vector< MODEL_EMBEDDED_IMAGE > images
std::vector< MODEL_TEXT > texts
std::vector< MODEL_PART_TYPE > partTypes
std::vector< MODEL_SHEET > sheets
std::vector< MODEL_PLACEMENT > placements
std::vector< PARSER_DIAGNOSTIC > diagnostics
STRING_ENCODING_STATUS encoding
std::vector< uint8_t > raw
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
static std::vector< uint8_t > bytes(const std::string &aText)
BOOST_AUTO_TEST_SUITE(CadstarPartParser)
BOOST_CHECK(res.column_datatype(0)==SQL_NUMERIC||res.column_datatype(0)==SQL_DECIMAL)
BOOST_REQUIRE_EQUAL(rows.size(), 1)
BOOST_CHECK_EQUAL(std::any_cast< std::string >(rows[0].at("val")), "12345678901234567.89")
BOOST_REQUIRE_MESSAGE(dc.CacheTableInfo(table, { "part_id", "val" }), dc.GetLastError())
BOOST_REQUIRE(res.columns()==1)
BOOST_CHECK_EQUAL_COLLECTIONS(mixed.begin(), mixed.end(), expMixed.begin(), expMixed.end())
BOOST_AUTO_TEST_SUITE_END()
VECTOR3I expected(15, 30, 45)
BOOST_AUTO_TEST_CASE(EmbeddedOleImages)
BOOST_TEST_CONTEXT("Test Clearance")
SHAPE_CIRCLE circle(c.m_circle_center, c.m_circle_radius)
wxString result
Test unit parsing edge cases and error handling.