KiCad PCB EDA Suite
Loading...
Searching...
No Matches
allegro_parser.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright Quilter
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 3
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
22
23#include <array>
24#include <cstring>
25
26#include <wx/sstream.h>
27#include <wx/log.h>
28#include <wx/translation.h>
29
30#include <core/profile.h>
31#include <core/throttle.h>
32#include <core/type_helpers.h>
33#include <ki_exception.h>
34
35using namespace ALLEGRO;
36
37
45static const wxChar* const traceAllegroParser = wxT( "KICAD_ALLEGRO_PARSER" );
46static const wxChar* const traceAllegroParserBlocks = wxT( "KICAD_ALLEGRO_PARSER_BLOCKS" );
47static const wxChar* const traceAllegroPerf = wxT( "KICAD_ALLEGRO_PERF" );
48
49
51{
52 // Every format version stores the tail (chain terminator) first, then the head
53 uint32_t tail = aStream.ReadU32();
54 uint32_t head = aStream.ReadU32();
55
57 .m_Tail = tail,
58 .m_Head = head,
59 };
60}
61
62
63static double ReadAllegroFloat( FILE_STREAM& aStream )
64{
65 const uint32_t a = aStream.ReadU32();
66 const uint32_t b = aStream.ReadU32();
67
68 // Combine into a 64-bit integer
69 const uint64_t combined = ( static_cast<uint64_t>( a ) << 32 ) + b;
70
71 // Copy the bits into a double
72 double result = 0;
73 std::memcpy( &result, &combined, sizeof( result ) );
74 return result;
75}
76
77
78template <typename ARRAY>
79static void ReadArrayU32( FILE_STREAM& aStream, ARRAY& aArray )
80{
81 for( size_t i = 0; i < aArray.size(); i++ )
82 {
83 aArray[i] = aStream.ReadU32();
84 }
85}
86
87
88template <typename T>
89static T ReadField( FILE_STREAM& aStream )
90{
91 T field;
92 if constexpr( std::is_same_v<T, uint32_t> )
93 {
94 field = aStream.ReadU32();
95 }
96 else if constexpr( std::is_same_v<T, uint8_t> )
97 {
98 field = aStream.ReadU8();
99 }
100 else if constexpr( std::is_same_v<T, uint16_t> )
101 {
102 field = aStream.ReadU16();
103 }
104 else if constexpr( std::is_same_v<T, int16_t> )
105 {
106 field = aStream.ReadS16();
107 }
108 else if constexpr( std::is_same_v<T, int32_t> )
109 {
110 field = aStream.ReadS32();
111 }
112 else if constexpr( std::is_same_v<T, FILE_HEADER::LINKED_LIST> )
113 {
114 field = ReadLL( aStream );
115 }
116 else if constexpr( requires { std::tuple_size<T>::value; } )
117 {
118 for( size_t i = 0; i < std::tuple_size_v<T>; ++i )
119 field[i] = aStream.ReadU32();
120 }
121 else
122 {
123 static_assert( always_false<T>::value, "Unsupported type for ReadField" );
124 }
125
126 return field;
127}
128
129
134template <typename COND_T>
135static void ReadCond( FILE_STREAM& aStream, FMT_VER aFmtVer, COND_T& aField )
136{
137 if( COND_T::exists( aFmtVer ) )
138 {
139 aField = ReadField<typename COND_T::value_type>( aStream );
140 }
141}
142
143
145{
146 uint32_t masked = aMagic & 0xFFFFFF00;
147
148 switch( masked )
149 {
150 case 0x00130000: return FMT_VER::V_160;
151 case 0x00130200: return FMT_VER::V_161;
152 case 0x00130400:
153 case 0x00130500: return FMT_VER::V_162;
154 case 0x00130C00: return FMT_VER::V_164;
155 case 0x00131000: return FMT_VER::V_165;
156 case 0x00131500: return FMT_VER::V_166;
157 case 0x00140400:
158 case 0x00140500:
159 case 0x00140600:
160 case 0x00140700: return FMT_VER::V_172;
161 case 0x00140900:
162 case 0x00140E00: return FMT_VER::V_174;
163 case 0x00141500: return FMT_VER::V_175;
164 case 0x00150000: return FMT_VER::V_180;
165 case 0x00150200: return FMT_VER::V_181;
166 case 0x00160100: return FMT_VER::V_190;
167 default: break;
168 }
169
170 // Pre-v16 Allegro files use a fundamentally different binary format
171 // that cannot be parsed by this importer. The header is still compatible enough to read
172 // the Allegro version string for a helpful error message.
173 uint32_t majorVer = ( aMagic >> 16 ) & 0xFFFF;
174
175 if( majorVer <= 0x0012 )
176 return FMT_VER::V_PRE_V16;
177
178 // Allegro 14 and 15 keep the family in the top byte of the magic
179 const uint32_t topByte = aMagic >> 24;
180
181 if( topByte >= 0x0F && topByte <= 0x12 && ( aMagic & 0x00FF0000 ) == 0 )
182 return FMT_VER::V_PRE_V16;
183
184 // Struct sizes depend on version, so we can't do anything useful with
185 // unrecognized formats. Report the magic and ask the user to report it.
186 THROW_IO_ERRORF( _( "Unknown Allegro file version %#010x (rev %d)" ), aMagic, majorVer - 3 );
187}
188
189
190std::unique_ptr<ALLEGRO::FILE_HEADER> HEADER_PARSER::ParseHeader()
191{
192 auto header = std::make_unique<ALLEGRO::FILE_HEADER>();
193 const size_t headerStartPos = m_stream.Position();
194
195 uint32_t fileMagic = m_stream.ReadU32();
196 m_fmtVer = FormatFromMagic( fileMagic );
197
198 header->m_Magic = fileMagic;
199
200 header->m_Unknown1a = m_stream.ReadU32();
201 header->m_FileRole = m_stream.ReadU32();
202 header->m_Unknown1b = m_stream.ReadU32();
203 header->m_WriterProgram = m_stream.ReadU32();
204
205 header->m_ObjectCount = m_stream.ReadU32();
206
207 header->m_UnknownMagic = m_stream.ReadU32();
208 header->m_UnknownFlags = m_stream.ReadU32();
209
210 ReadCond( m_stream, m_fmtVer, header->m_Unknown2_preV18 );
211
212 ReadCond( m_stream, m_fmtVer, header->m_Unknown2a_V18 );
213 ReadCond( m_stream, m_fmtVer, header->m_Unknown2b_V18 );
214 ReadCond( m_stream, m_fmtVer, header->m_0x27_End_V18 );
215 ReadCond( m_stream, m_fmtVer, header->m_Unknown2d_V18 );
216 ReadCond( m_stream, m_fmtVer, header->m_Unknown2e_V18 );
217 ReadCond( m_stream, m_fmtVer, header->m_StringCount_V18 );
218 ReadCond( m_stream, m_fmtVer, header->m_Unknown2g_V18 );
219
220 ReadCond( m_stream, m_fmtVer, header->m_Unknown2h_V18 );
221
222 header->m_LL_0x04 = ReadLL( m_stream );
223 header->m_LL_0x06 = ReadLL( m_stream );
224 header->m_LL_0x0C = ReadLL( m_stream );
225 header->m_LL_Shapes = ReadLL( m_stream );
226 header->m_LL_0x14 = ReadLL( m_stream );
227 header->m_LL_0x1B_Nets = ReadLL( m_stream );
228 header->m_LL_0x1C = ReadLL( m_stream );
229 header->m_LL_0x24_0x28 = ReadLL( m_stream );
230 header->m_LL_Unknown1 = ReadLL( m_stream );
231 header->m_LL_0x2B = ReadLL( m_stream );
232 header->m_LL_0x03_0x30 = ReadLL( m_stream );
233 header->m_LL_0x0A = ReadLL( m_stream );
234 header->m_LL_0x1D_0x1E_0x1F = ReadLL( m_stream );
235 header->m_LL_Unknown2 = ReadLL( m_stream );
236 header->m_LL_0x38 = ReadLL( m_stream );
237 header->m_LL_0x2C = ReadLL( m_stream );
238 header->m_LL_0x0C_2 = ReadLL( m_stream );
239 header->m_LL_Unknown3 = ReadLL( m_stream );
240
241 header->m_LL_0x35 = ReadLL( m_stream );
242 header->m_LL_0x36 = ReadLL( m_stream );
243 header->m_LL_Unknown4 = ReadLL( m_stream );
244 header->m_LL_Unknown5 = ReadLL( m_stream );
245 header->m_LL_0x0A_2 = ReadLL( m_stream );
246
247 ReadCond( m_stream, m_fmtVer, header->m_LL_0x03_2 );
248
249 header->m_Unknown_LlTrailer = m_stream.ReadU32();
250
251 ReadCond( m_stream, m_fmtVer, header->m_Unknown_V181 );
252
253 // Quick check that the positions line up
254 // (start of the m_AllegroVersion string is easy to find)
256 wxASSERT( m_stream.Position() - headerStartPos == 0xF8 );
257 else if( m_fmtVer < FMT_VER::V_181 )
258 wxASSERT( m_stream.Position() - headerStartPos == 0x124 );
259 else
260 wxASSERT( m_stream.Position() - headerStartPos == 0x144 );
261
262 m_stream.ReadBytes( header->m_AllegroVersion.data(), header->m_AllegroVersion.size() );
263 header->m_Unknown4 = m_stream.ReadU32();
264 header->m_MaxKey = m_stream.ReadU32();
265
266 ReadCond( m_stream, m_fmtVer, header->m_Unknown5_preV18 );
267 ReadCond( m_stream, m_fmtVer, header->m_Unknown5_V18 );
268
269 {
270 uint8_t units = m_stream.ReadU8();
271
272 switch( units )
273 {
279 header->m_BoardUnits = static_cast<BOARD_UNITS>( units );
280 break;
281
282 default:
283 THROW_IO_ERRORF( _( "Unknown board units %d" ), units );
284 }
285
286 m_stream.Skip( 3 );
287 }
288
289 header->m_Unknown6 = m_stream.ReadU32();
290
291 ReadCond( m_stream, m_fmtVer, header->m_Unknown7 );
292 ReadCond( m_stream, m_fmtVer, header->m_0x27_End_preV18 );
293
294 header->m_Unknown8 = m_stream.ReadU32();
295
296 ReadCond( m_stream, m_fmtVer, header->m_StringCount_preV18 );
297
298 ReadArrayU32( m_stream, header->m_Unknown9 );
299
300 header->m_Unknown10a = m_stream.ReadU32();
301 header->m_Unknown10b = m_stream.ReadU32();
302 header->m_Unknown10c = m_stream.ReadU32();
303
304 header->m_UnitsDivisor = m_stream.ReadU32();
305
306 m_stream.SkipU32( m_fmtVer >= FMT_VER::V_181 ? 102 : 110 );
307
308 for( size_t i = 0; i < header->m_LayerMap.size(); ++i )
309 {
310 header->m_LayerMap[i].m_A = m_stream.ReadU32();
311 header->m_LayerMap[i].m_LayerList0x2A = m_stream.ReadU32();
312 }
313
314 wxLogTrace( traceAllegroParser, wxT( "Parsed header: %d objects, %d strings" ), header->m_ObjectCount,
315 header->GetStringsCount() );
316
317 return header;
318}
319
320
321static void ReadStringMap( FILE_STREAM& stream, BRD_DB& aDb, uint32_t count )
322{
323 // Fixed file offset of the string table in Allegro board files.
324 // As far as known, this is always a fixed value.
325 static constexpr size_t STRING_TABLE_OFFSET = 0x1200;
326
327 stream.Seek( STRING_TABLE_OFFSET );
328
329 for( uint32_t i = 0; i < count; ++i )
330 {
331 uint32_t id = stream.ReadU32();
332 wxString str = stream.ReadString( true );
333
334 aDb.AddString( id, std::move( str ) );
335 }
336}
337
338
340{
341 uint8_t classCode = aStream.ReadU8();
342 uint8_t subclassCode = aStream.ReadU8();
343
344 // Don't try to be clever and assign enums here - there are loads of them,
345 // and we don't have a perfect map yet.
346 return LAYER_INFO{
347 .m_Class = classCode,
348 .m_Subclass = subclassCode,
349 };
350}
351
352
353static std::unique_ptr<BLOCK_BASE> ParseBlock_0x01_ARC( FILE_STREAM& aStream, FMT_VER aVer )
354{
355 auto block = std::make_unique<BLOCK<BLK_0x01_ARC>>( aStream.Position() );
356
357 auto& data = block->GetData();
358
359 aStream.Skip( 1 );
360
361 data.m_UnknownByte = aStream.ReadU8();
362 data.m_SubType = aStream.ReadU8();
363 data.m_Key = aStream.ReadU32();
364 block->SetKey( data.m_Key );
365 data.m_Next = aStream.ReadU32();
366 block->SetNext( data.m_Next );
367 data.m_Parent = aStream.ReadU32();
368 data.m_Unknown1 = aStream.ReadU32();
369
370 ReadCond( aStream, aVer, data.m_Unknown6 );
371
372 data.m_Width = aStream.ReadU32();
373
374 data.m_StartX = aStream.ReadS32();
375 data.m_StartY = aStream.ReadS32();
376 data.m_EndX = aStream.ReadS32();
377 data.m_EndY = aStream.ReadS32();
378
379 data.m_CenterX = ReadAllegroFloat( aStream );
380 data.m_CenterY = ReadAllegroFloat( aStream );
381 data.m_Radius = ReadAllegroFloat( aStream );
382
383 for( size_t i = 0; i < data.m_BoundingBoxCoords.size(); ++i )
384 {
385 data.m_BoundingBoxCoords[i] = aStream.ReadS32();
386 }
387
388 return block;
389}
390
391
392static std::unique_ptr<BLOCK_BASE> ParseBlock_0x03( FILE_STREAM& aStream, FMT_VER aVer )
393{
394 auto block = std::make_unique<BLOCK<BLK_0x03_FIELD>>( aStream.Position() );
395
396 auto& data = block->GetData();
397
398 aStream.Skip( 1 );
399
400 data.m_Hdr1 = aStream.ReadU16();
401 data.m_Key = aStream.ReadU32();
402 block->SetKey( data.m_Key );
403 data.m_Next = aStream.ReadU32();
404 block->SetNext( data.m_Next );
405
406 ReadCond( aStream, aVer, data.m_Unknown1 );
407
408 data.m_SubType = aStream.ReadU8();
409 data.m_Hdr2 = aStream.ReadU8();
410 data.m_Size = aStream.ReadU16();
411
412 ReadCond( aStream, aVer, data.m_Unknown2 );
413
414 wxLogTrace( traceAllegroParserBlocks, wxT( " Parsed block 0x03: subtype %#02x, size %d" ), data.m_SubType,
415 data.m_Size );
416
417 switch( data.m_SubType )
418 {
419 case 0x65:
420 // Nothing for this one?
421 break;
422 case 0x64:
423 case 0x66:
424 case 0x67:
425 case 0x6A:
426 {
427 data.m_Substruct = aStream.ReadU32();
428 break;
429 }
430 case 0x69:
431 {
432 data.m_Substruct = std::array<uint32_t, 2>{
433 aStream.ReadU32(),
434 aStream.ReadU32(),
435 };
436 break;
437 }
438 case 0x68:
439 case 0x6B:
440 case 0x6D:
441 case 0x6E:
442 case 0x6F:
443 case 0x71:
444 case 0x73:
445 case 0x78:
446 {
447 data.m_Substruct = aStream.ReadStringFixed( data.m_Size, true );
448 break;
449 }
450 case 0x6C:
451 {
453 sub.m_NumEntries = aStream.ReadU32();
454
455 if( sub.m_NumEntries > 1000000 )
456 {
457 THROW_IO_ERRORF( wxT( "Block 0x03 subtype 0x6C entry count %u exceeds limit at offset %#010zx" ),
458 sub.m_NumEntries, aStream.Position() );
459 }
460
461 sub.m_Entries.reserve( sub.m_NumEntries );
462 for( uint32_t i = 0; i < sub.m_NumEntries; ++i )
463 {
464 sub.m_Entries.push_back( aStream.ReadU32() );
465 }
466
467 data.m_Substruct = std::move( sub );
468 break;
469 }
470 case 0x70:
471 case 0x74:
472 {
474
475 sub.m_X0 = aStream.ReadU16();
476 sub.m_X1 = aStream.ReadU16();
477
478 const size_t numEntries = ( sub.m_X1 + 4 * sub.m_X0 );
479 sub.m_Entries.reserve( numEntries );
480 for( size_t i = 0; i < numEntries; ++i )
481 {
482 sub.m_Entries.push_back( aStream.ReadU8() );
483 }
484 data.m_Substruct = std::move( sub );
485 break;
486 }
487 case 0xF6:
488 {
490 for( size_t i = 0; i < sub.m_Entries.size(); ++i )
491 {
492 sub.m_Entries[i] = aStream.ReadU32();
493 }
494 data.m_Substruct = std::move( sub );
495 break;
496 }
497 default:
498 {
499 if( data.m_Size == 4 )
500 {
501 data.m_Substruct = aStream.ReadU32();
502 }
503 else if( data.m_Size == 8 )
504 {
505 std::array<uint32_t, 2> sub;
506 sub[0] = aStream.ReadU32();
507 sub[1] = aStream.ReadU32();
508 data.m_Substruct = std::move( sub );
509 }
510 else
511 {
512 THROW_IO_ERRORF( wxT( "Unknown substruct type %#02x with size %d" ), data.m_SubType, data.m_Size );
513 }
514 break;
515 }
516 }
517
518 return block;
519}
520
521
522static std::unique_ptr<BLOCK_BASE> ParseBlock_0x04_NET_ASSIGNMENT( FILE_STREAM& aStream, FMT_VER aVer )
523{
524 auto block = std::make_unique<BLOCK<BLK_0x04_NET_ASSIGNMENT>>( aStream.Position() );
525
526 auto& data = block->GetData();
527
528 data.m_Type = aStream.ReadU8();
529 data.m_R = aStream.ReadU16();
530 data.m_Key = aStream.ReadU32();
531 block->SetKey( data.m_Key );
532 data.m_Next = aStream.ReadU32();
533 block->SetNext( data.m_Next );
534 data.m_Net = aStream.ReadU32();
535 data.m_ConnItem = aStream.ReadU32();
536
537 ReadCond( aStream, aVer, data.m_Unknown );
538
539 return block;
540}
541
542
543static std::unique_ptr<BLOCK_BASE> ParseBlock_0x05_TRACK( FILE_STREAM& aStream, FMT_VER aVer )
544{
545 auto block = std::make_unique<BLOCK<BLK_0x05_TRACK>>( aStream.Position() );
546
547 auto& data = block->GetData();
548
549 aStream.Skip( 1 );
550
551 data.m_Layer = ParseLayerInfo( aStream );
552 data.m_Key = aStream.ReadU32();
553 block->SetKey( data.m_Key );
554 data.m_Next = aStream.ReadU32();
555 block->SetNext( data.m_Next );
556 data.m_NetAssignment = aStream.ReadU32();
557 data.m_UnknownPtr1 = aStream.ReadU32();
558 data.m_Unknown2 = aStream.ReadU32();
559 data.m_Unknown3 = aStream.ReadU32();
560 data.m_UnknownPtr2a = aStream.ReadU32();
561 data.m_UnknownPtr2b = aStream.ReadU32();
562 data.m_Unknown4 = aStream.ReadU32();
563 data.m_UnknownPtr3a = aStream.ReadU32();
564 data.m_UnknownPtr3b = aStream.ReadU32();
565
566 ReadCond( aStream, aVer, data.m_Unknown5a );
567 ReadCond( aStream, aVer, data.m_Unknown5b );
568
569 data.m_FirstSegPtr = aStream.ReadU32();
570 data.m_UnknownPtr5 = aStream.ReadU32();
571 data.m_Unknown6 = aStream.ReadU32();
572
573 return block;
574}
575
576
577static std::unique_ptr<BLOCK_BASE> ParseBlock_0x06( FILE_STREAM& stream, FMT_VER aVer )
578{
579 auto block = std::make_unique<BLOCK<BLK_0x06_COMPONENT>>( stream.Position() );
580
581 auto& data = block->GetData();
582
583 stream.Skip( 3 );
584
585 data.m_Key = stream.ReadU32();
586 block->SetKey( data.m_Key );
587 data.m_Next = stream.ReadU32();
588 block->SetNext( data.m_Next );
589 data.m_CompDeviceType = stream.ReadU32();
590 data.m_SymbolName = stream.ReadU32();
591 data.m_FirstInstPtr = stream.ReadU32();
592 data.m_PtrFunctionSlot = stream.ReadU32();
593 data.m_PtrPinNumber = stream.ReadU32();
594 data.m_Fields = stream.ReadU32();
595
596 ReadCond( stream, aVer, data.m_Unknown1 );
597
598 return block;
599}
600
601
602static std::unique_ptr<BLOCK_BASE> ParseBlock_0x07( FILE_STREAM& stream, FMT_VER aVer )
603{
604 auto block = std::make_unique<BLOCK<BLK_0x07_COMPONENT_INST>>( stream.Position() );
605
606 auto& data = block->GetData();
607
608 stream.Skip( 3 );
609
610 data.m_Key = stream.ReadU32();
611 block->SetKey( data.m_Key );
612 data.m_Next = stream.ReadU32();
613 block->SetNext( data.m_Next );
614
615 ReadCond( stream, aVer, data.m_UnknownPtr1 );
616 ReadCond( stream, aVer, data.m_Unknown2 );
617 ReadCond( stream, aVer, data.m_Unknown3 );
618
619 data.m_FpInstPtr = stream.ReadU32();
620
621 ReadCond( stream, aVer, data.m_Unknown4 );
622
623 data.m_RefDesStrPtr = stream.ReadU32();
624 data.m_FunctionInstPtr = stream.ReadU32();
625 data.m_X03Ptr = stream.ReadU32();
626 data.m_Unknown5 = stream.ReadU32();
627 data.m_FirstPadPtr = stream.ReadU32();
628
629 return block;
630}
631
632
633static std::unique_ptr<BLOCK_BASE> ParseBlock_0x08( FILE_STREAM& aStream, FMT_VER aVer )
634{
635 auto block = std::make_unique<BLOCK<BLK_0x08_PIN_NUMBER>>( aStream.Position() );
636
637 auto& data = block->GetData();
638
639 data.m_Type = aStream.ReadU8();
640 data.m_R = aStream.ReadU16();
641 data.m_Key = aStream.ReadU32();
642 block->SetKey( data.m_Key );
643
644 ReadCond( aStream, aVer, data.m_Previous );
645 ReadCond( aStream, aVer, data.m_StrPtr16x );
646
647 data.m_Next = aStream.ReadU32();
648 block->SetNext( data.m_Next );
649
650 ReadCond( aStream, aVer, data.m_StrPtr );
651
652 data.m_PinNamePtr = aStream.ReadU32();
653
654 ReadCond( aStream, aVer, data.m_Unknown1 );
655
656 data.m_Ptr4 = aStream.ReadU32();
657
658 return block;
659}
660
661
662static std::unique_ptr<BLOCK_BASE> ParseBlock_0x09( FILE_STREAM& aStream, FMT_VER aVer )
663{
664 auto block = std::make_unique<BLOCK<BLK_0x09_FILL_LINK>>( aStream.Position() );
665
666 auto& data = block->GetData();
667
668 aStream.Skip( 3 );
669
670 data.m_Key = aStream.ReadU32();
671 block->SetKey( data.m_Key );
672
673 for( size_t i = 0; i < data.m_UnknownArray.size(); ++i )
674 {
675 data.m_UnknownArray[i] = aStream.ReadU32();
676 }
677
678 ReadCond( aStream, aVer, data.m_Unknown1 );
679
680 data.m_UnknownPtr1 = aStream.ReadU32();
681 data.m_UnknownPtr2 = aStream.ReadU32();
682 data.m_Unknown2 = aStream.ReadU32();
683 data.m_UnknownPtr3 = aStream.ReadU32();
684 data.m_UnknownPtr4 = aStream.ReadU32();
685
686 ReadCond( aStream, aVer, data.m_Unknown3 );
687
688 return block;
689}
690
691
692static std::unique_ptr<BLOCK_BASE> ParseBlock_0x0A_DRC( FILE_STREAM& aStream, FMT_VER aVer )
693{
694 auto block = std::make_unique<BLOCK<BLK_0x0A_DRC>>( aStream.Position() );
695
696 auto& data = block->GetData();
697
698 data.m_T = aStream.ReadU8();
699 data.m_Layer = ParseLayerInfo( aStream );
700 data.m_Key = aStream.ReadU32();
701 block->SetKey( data.m_Key );
702 data.m_Next = aStream.ReadU32();
703 block->SetNext( data.m_Next );
704 data.m_Unknown1 = aStream.ReadU32();
705
706 ReadCond( aStream, aVer, data.m_Unknown2 );
707
708 for( size_t i = 0; i < data.m_Coords.size(); ++i )
709 {
710 data.m_Coords[i] = aStream.ReadS32();
711 }
712
713 ReadArrayU32( aStream, data.m_Unknown4 );
714 ReadArrayU32( aStream, data.m_Unknown5 );
715
716 ReadCond( aStream, aVer, data.m_Unknown6 );
717
718 return block;
719}
720
721
722static std::unique_ptr<BLOCK_BASE> ParseBlock_0x0C( FILE_STREAM& aStream, FMT_VER aVer )
723{
724 auto block = std::make_unique<BLOCK<BLK_0x0C_PIN_DEF>>( aStream.Position() );
725
726 auto& data = block->GetData();
727
728 data.m_T = aStream.ReadU8();
729 data.m_Layer = ParseLayerInfo( aStream );
730
731 data.m_Key = aStream.ReadU32();
732 block->SetKey( data.m_Key );
733 data.m_Next = aStream.ReadU32();
734 block->SetNext( data.m_Next );
735
736 data.m_Unknown1 = aStream.ReadU32();
737 data.m_Unknown2 = aStream.ReadU32();
738
739 // Older packed format
740 ReadCond( aStream, aVer, data.m_Shape );
741 ReadCond( aStream, aVer, data.m_DrillChar );
742 ReadCond( aStream, aVer, data.m_UnknownPadding );
743
744 // V17.2+
745 ReadCond( aStream, aVer, data.m_Shape16x );
746 ReadCond( aStream, aVer, data.m_DrillChars );
747 ReadCond( aStream, aVer, data.m_Unknown_16x );
748
749 data.m_Unknown4 = aStream.ReadU32();
750 ReadCond( aStream, aVer, data.m_Unknown5 );
751
752 for( size_t i = 0; i < data.m_Coords.size(); ++i )
753 {
754 data.m_Coords[i] = aStream.ReadS32();
755 }
756
757 for( size_t i = 0; i < data.m_Size.size(); ++i )
758 {
759 data.m_Size[i] = aStream.ReadS32();
760 }
761
762 data.m_GroupPtr = aStream.ReadU32();
763 data.m_Unknown6 = aStream.ReadU32();
764 data.m_Unknown7 = aStream.ReadU32();
765
766 ReadCond( aStream, aVer, data.m_Unknown8 );
767
768 return block;
769}
770
771
772static std::unique_ptr<BLOCK_BASE> ParseBlock_0x0D_PAD( FILE_STREAM& aStream, FMT_VER aVer )
773{
774 auto block = std::make_unique<BLOCK<BLK_0x0D_PAD>>( aStream.Position() );
775
776 auto& data = block->GetData();
777
778 aStream.Skip( 3 );
779
780 data.m_Key = aStream.ReadU32();
781 block->SetKey( data.m_Key );
782 data.m_NameStrId = aStream.ReadU32();
783 data.m_Next = aStream.ReadU32();
784 block->SetNext( data.m_Next );
785
786 ReadCond( aStream, aVer, data.m_Unknown1 );
787
788 data.m_CoordsX = aStream.ReadS32();
789 data.m_CoordsY = aStream.ReadS32();
790
791 data.m_PadStack = aStream.ReadU32();
792 data.m_Unknown2 = aStream.ReadU32();
793
794 ReadCond( aStream, aVer, data.m_Unknown3 );
795
796 data.m_Flags = aStream.ReadU32();
797 data.m_Rotation = aStream.ReadU32();
798
799 return block;
800}
801
802
803static std::unique_ptr<BLOCK_BASE> ParseBlock_0x0E( FILE_STREAM& aStream, FMT_VER aVer )
804{
805 auto block = std::make_unique<BLOCK<BLK_0x0E_RECT>>( aStream.Position() );
806
807 auto& data = block->GetData();
808
809 data.m_T = aStream.ReadU8();
810 data.m_Layer = ParseLayerInfo( aStream );
811 data.m_Key = aStream.ReadU32();
812 block->SetKey( data.m_Key );
813 data.m_Next = aStream.ReadU32();
814 block->SetNext( data.m_Next );
815 data.m_FpPtr = aStream.ReadU32();
816
817 data.m_Unknown1 = aStream.ReadU32();
818 data.m_Unknown2 = aStream.ReadU32();
819 data.m_Unknown3 = aStream.ReadU32();
820
821 ReadCond( aStream, aVer, data.m_Unknown4 );
822 ReadCond( aStream, aVer, data.m_Unknown5 );
823
824 for( size_t i = 0; i < data.m_Coords.size(); ++i )
825 {
826 data.m_Coords[i] = aStream.ReadS32();
827 }
828
829 for( size_t i = 0; i < data.m_UnknownArr.size(); ++i )
830 {
831 data.m_UnknownArr[i] = aStream.ReadU32();
832 }
833
834 data.m_Rotation = aStream.ReadU32();
835
836 return block;
837}
838
839
840static std::unique_ptr<BLOCK_BASE> ParseBlock_0x0F( FILE_STREAM& stream, FMT_VER aVer )
841{
842 auto block = std::make_unique<BLOCK<BLK_0x0F_FUNCTION_SLOT>>( stream.Position() );
843
844 auto& data = block->GetData();
845
846 stream.Skip( 3 );
847
848 data.m_Key = stream.ReadU32();
849 block->SetKey( data.m_Key );
850 data.m_SlotName = stream.ReadU32();
851
852 ReadCond( stream, aVer, data.m_Unknown1 );
853
854 if( aVer < FMT_VER::V_190 )
855 stream.ReadBytes( data.m_CompDeviceType.data(), data.m_CompDeviceType.size() );
856
857 ReadCond( stream, aVer, data.m_CompDeviceTypePtr );
858
859 ReadCond( stream, aVer, data.m_Next );
860 block->SetNext( data.m_Next.value_or( 0 ) );
861
862 data.m_Ptr0x06 = stream.ReadU32();
863 data.m_Ptr0x11 = stream.ReadU32();
864 data.m_Unknown2 = stream.ReadU32();
865
866 return block;
867}
868
869
870static std::unique_ptr<BLOCK_BASE> ParseBlock_0x10( FILE_STREAM& stream, FMT_VER aVer )
871{
872 auto block = std::make_unique<BLOCK<BLK_0x10_FUNCTION_INST>>( stream.Position() );
873
874 auto& data = block->GetData();
875
876 stream.Skip( 3 );
877
878 data.m_Key = stream.ReadU32();
879 block->SetKey( data.m_Key );
880
881 ReadCond( stream, aVer, data.m_Unknown1 );
882 data.m_ComponentInstPtr = stream.ReadU32();
883 ReadCond( stream, aVer, data.m_Unknown2 );
884 data.m_PtrX12 = stream.ReadU32();
885 data.m_Unknown3 = stream.ReadU32();
886 data.m_FunctionName = stream.ReadU32();
887 data.m_Slots = stream.ReadU32();
888 data.m_Fields = stream.ReadU32();
889
890 return block;
891}
892
893
894static std::unique_ptr<BLOCK_BASE> ParseBlock_0x11( FILE_STREAM& aStream, FMT_VER aVer )
895{
896 auto block = std::make_unique<BLOCK<BLK_0x11_PIN_NAME>>( aStream.Position() );
897
898 auto& data = block->GetData();
899
900 data.m_Type = aStream.ReadU8();
901 data.m_R = aStream.ReadU16();
902 data.m_Key = aStream.ReadU32();
903 block->SetKey( data.m_Key );
904 data.m_PinNameStrPtr = aStream.ReadU32();
905 data.m_Next = aStream.ReadU32();
906 block->SetNext( data.m_Next );
907 data.m_PinNumberPtr = aStream.ReadU32();
908 data.m_Unknown1 = aStream.ReadU32();
909
910 ReadCond( aStream, aVer, data.m_Unknown2 );
911
912 return block;
913}
914
915
916static std::unique_ptr<BLOCK_BASE> ParseBlock_0x12( FILE_STREAM& aStream, FMT_VER aVer )
917{
918 auto block = std::make_unique<BLOCK<BLK_0x12_XREF>>( aStream.Position() );
919
920 auto& data = block->GetData();
921
922 data.m_Type = aStream.ReadU8();
923 data.m_R = aStream.ReadU16();
924 data.m_Key = aStream.ReadU32();
925 block->SetKey( data.m_Key );
926 data.m_Ptr1 = aStream.ReadU32();
927 data.m_Ptr2 = aStream.ReadU32();
928 data.m_Ptr3 = aStream.ReadU32();
929 data.m_Unknown1 = aStream.ReadU32();
930
931 ReadCond( aStream, aVer, data.m_Unknown2 );
932 ReadCond( aStream, aVer, data.m_Unknown3 );
933
934 return block;
935}
936
937
938static std::unique_ptr<BLOCK_BASE> ParseBlock_0x14( FILE_STREAM& aStream, FMT_VER aVer )
939{
940 auto block = std::make_unique<BLOCK<BLK_0x14_GRAPHIC>>( aStream.Position() );
941
942 auto& data = block->GetData();
943
944 data.m_Type = aStream.ReadU8();
945 data.m_Layer = ParseLayerInfo( aStream );
946 data.m_Key = aStream.ReadU32();
947 block->SetKey( data.m_Key );
948 data.m_Next = aStream.ReadU32();
949 block->SetNext( data.m_Next );
950 data.m_Parent = aStream.ReadU32();
951 data.m_Flags = aStream.ReadU32();
952
953 ReadCond( aStream, aVer, data.m_Unknown2 );
954
955 data.m_SegmentPtr = aStream.ReadU32();
956 data.m_Ptr0x03 = aStream.ReadU32();
957 data.m_Ptr0x26 = aStream.ReadU32();
958
959 return block;
960}
961
962
963static std::unique_ptr<BLOCK_BASE> ParseBlock_0x15_16_17_SEGMENT( FILE_STREAM& aStream, FMT_VER aVer, uint8_t aType )
964{
965 auto block = std::make_unique<BLOCK<BLK_0x15_16_17_SEGMENT>>( aType, aStream.Position() );
966
967 auto& data = block->GetData();
968
969 aStream.Skip( 3 );
970
971 data.m_Key = aStream.ReadU32();
972 block->SetKey( data.m_Key );
973 data.m_Next = aStream.ReadU32();
974 block->SetNext( data.m_Next );
975 data.m_Parent = aStream.ReadU32();
976 data.m_Flags = aStream.ReadU32();
977
978 ReadCond( aStream, aVer, data.m_Unknown2 );
979
980 data.m_Width = aStream.ReadU32();
981
982 data.m_StartX = aStream.ReadS32();
983 data.m_StartY = aStream.ReadS32();
984 data.m_EndX = aStream.ReadS32();
985 data.m_EndY = aStream.ReadS32();
986
987 return block;
988}
989
990
991static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1A( FILE_STREAM& aStream, FMT_VER aVer )
992{
993 auto block = std::make_unique<BLOCK<BLK_0x1A_UNKNOWN>>( aStream.Position() );
994
995 auto& data = block->GetData();
996
997 data.m_Type = aStream.ReadU8();
998 data.m_T2 = aStream.ReadU16();
999 data.m_Key = aStream.ReadU32();
1000 block->SetKey( data.m_Key );
1001
1002 ReadArrayU32( aStream, data.m_UnknownArray );
1003
1004 return block;
1005}
1006
1007
1008static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1B_NET( FILE_STREAM& stream, FMT_VER aVer )
1009{
1010 auto block = std::make_unique<BLOCK<BLK_0x1B_NET>>( stream.Position() );
1011
1012 auto& data = block->GetData();
1013
1014 stream.Skip( 3 );
1015
1016 data.m_Key = stream.ReadU32();
1017 block->SetKey( data.m_Key );
1018 data.m_Next = stream.ReadU32();
1019 block->SetNext( data.m_Next );
1020 data.m_NetName = stream.ReadU32();
1021 data.m_Unknown1 = stream.ReadU32();
1022
1023 ReadCond( stream, aVer, data.m_Unknown2 );
1024
1025 data.m_Type = stream.ReadU32();
1026 data.m_Assignment = stream.ReadU32();
1027 data.m_Ratline = stream.ReadU32();
1028 data.m_FieldsPtr = stream.ReadU32();
1029 data.m_MatchGroupPtr = stream.ReadU32();
1030 data.m_ModelPtr = stream.ReadU32();
1031 data.m_UnknownPtr4 = stream.ReadU32();
1032 data.m_UnknownPtr5 = stream.ReadU32();
1033 data.m_UnknownPtr6 = stream.ReadU32();
1034
1035 return block;
1036}
1037
1038
1039static PAD_TYPE decodePadType( uint8_t aVal )
1040{
1041 // clang-format off
1042 switch( (aVal & 0xF0) )
1043 {
1044 case 0x00:
1045 return PAD_TYPE::THROUGH_VIA;
1046 case 0x10:
1047 return PAD_TYPE::VIA;
1048 break;
1049 case 0x20:
1050 case 0xa0: // Unclear what the difference is
1051 return PAD_TYPE::SMD_PIN;
1052 case 0x30:
1053 return PAD_TYPE::SLOT;
1054 break;
1055 case 0x80:
1056 return PAD_TYPE::NPTH;
1057 break;
1058 default:
1059 THROW_IO_ERRORF( wxT( "Unknown padstack type 0x%x" ), aVal );
1060 break;
1061 }
1062};
1063
1064
1065static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1C_PADSTACK( FILE_STREAM& aStream, FMT_VER aVer )
1066{
1067 auto block = std::make_unique<BLOCK<BLK_0x1C_PADSTACK>>( aStream.Position() );
1068
1069 auto& data = block->GetData();
1070
1071 data.m_UnknownByte1 = aStream.ReadU8();
1072 data.m_N = aStream.ReadU8();
1073 data.m_StartLayer = aStream.ReadU8();
1074
1075 data.m_Key = aStream.ReadU32();
1076 block->SetKey( data.m_Key );
1077 data.m_Next = aStream.ReadU32();
1078 block->SetNext( data.m_Next );
1079 data.m_PadStr = aStream.ReadU32();
1080
1081 if( aVer < FMT_VER::V_172 )
1082 {
1083 BLK_0x1C_PADSTACK::HEADER_v16x& hdr = data.m_Header.emplace<BLK_0x1C_PADSTACK::HEADER_v16x>();
1084
1085 hdr.m_DrillSize = aStream.ReadU32();
1086 hdr.m_UnknownStr = aStream.ReadU32();
1087 hdr.m_DrillMarkSizeX = aStream.ReadU32();
1088 hdr.m_DrillMarkSizeY = aStream.ReadU32();
1089 hdr.m_DrillOffsetX = aStream.ReadU32();
1090 hdr.m_DrillOffsetY = aStream.ReadU32();
1091
1092 hdr.m_DrillMarkShape = aStream.ReadU8();
1093 hdr.m_Flags = aStream.ReadU8();
1094 hdr.m_DrillChar = aStream.ReadU8();
1095 hdr.m_D = aStream.ReadU8();
1096 hdr.m_Unknown_1 = aStream.ReadU16();
1097
1098 hdr.m_ArrayNX = aStream.ReadU16();
1099 hdr.m_ArrayNY = aStream.ReadU16();
1100
1101 hdr.m_LayerCount = aStream.ReadU16();
1102 hdr.m_ClearanceX = aStream.ReadU32();
1103 hdr.m_ClearanceY = aStream.ReadU32();
1104 hdr.m_TolerancePos = aStream.ReadU32();
1105 hdr.m_ToleranceNeg = aStream.ReadU32();
1106
1107 hdr.m_Unknown_2 = aStream.ReadU32();
1108 hdr.m_SlotX = aStream.ReadU32();
1109 hdr.m_SlotY = aStream.ReadU32();
1110 hdr.m_Unknown_3 = aStream.ReadU32();
1111
1112 ReadCond( aStream, aVer, hdr.m_Unknown_4 );
1113 }
1114 else
1115 {
1116 BLK_0x1C_PADSTACK::HEADER_v17x& hdr = data.m_Header.emplace<BLK_0x1C_PADSTACK::HEADER_v17x>();
1117
1118 hdr.m_UnknownStr = aStream.ReadU32();
1119 hdr.m_Unknown1 = aStream.ReadU32();
1120 hdr.m_Unknown2 = aStream.ReadU32();
1121
1122 uint8_t padTypeAndA = aStream.ReadU8();
1123 hdr.m_PadType = decodePadType( padTypeAndA );
1124 hdr.m_A = ( padTypeAndA & 0x0F );
1125
1126 hdr.m_B = aStream.ReadU8();
1127 hdr.m_Flags = aStream.ReadU8();
1128 hdr.m_D = aStream.ReadU8();
1129
1130 hdr.m_unknown3 = aStream.ReadU32();
1131 hdr.m_Unknown4 = aStream.ReadU32();
1132 hdr.m_ArrayNX = aStream.ReadU16();
1133 hdr.m_ArrayNY = aStream.ReadU16();
1134 hdr.m_LayerCount = aStream.ReadU16();
1135 hdr.m_Unknown5 = aStream.ReadU16();
1136
1137 hdr.m_ClearanceX = aStream.ReadU32();
1138 hdr.m_ClearanceY = aStream.ReadU32();
1139
1140 hdr.m_Unknown6a = aStream.ReadU32();
1141 hdr.m_Unknown6b = aStream.ReadU32();
1142
1143 hdr.m_DrillSize = aStream.ReadU32();
1144 hdr.m_TolerancePos = aStream.ReadU32();
1145 hdr.m_ToleranceNeg = aStream.ReadU32();
1146
1147 hdr.m_SlotX = aStream.ReadU32();
1148 hdr.m_SlotY = aStream.ReadU32();
1149
1150 hdr.m_ToleranceTravelPos = aStream.ReadU32();
1151 hdr.m_ToleranceTravelNeg = aStream.ReadU32();
1152
1153 hdr.m_DrillMarkSizeX = aStream.ReadU32();
1154 hdr.m_DrillMarkSizeY = aStream.ReadU32();
1155 hdr.m_DrillMarkShape = aStream.ReadU32();
1156 hdr.m_DrillChars = aStream.ReadU32();
1157
1158 ReadArrayU32( aStream, hdr.m_UnknownArr3 );
1159
1160 ReadCond( aStream, aVer, hdr.m_UnknownArr_v180 );
1161 }
1162
1163 // Chekc the layer count isn't massive - malformed files could make this huge
1164 static const uint16_t MAX_LAYER_COUNT = 256;
1165 if( data.GetLayerCount() > MAX_LAYER_COUNT )
1166 throw std::runtime_error( "Layer count exceeds maximum of " + std::to_string( MAX_LAYER_COUNT ) );
1167
1168 // Work out how many fixed slots we have
1169 if( aVer < FMT_VER::V_165 )
1170 data.m_NumFixedCompEntries = 10;
1171 else if( aVer < FMT_VER::V_172 )
1172 data.m_NumFixedCompEntries = 11;
1173 else
1174 data.m_NumFixedCompEntries = 21;
1175
1176 // ...and how many per-layer slots
1177 data.m_NumCompsPerLayer = aVer < FMT_VER::V_172 ? 3 : 4;
1178
1179 const size_t nComps = data.m_NumFixedCompEntries + ( data.GetLayerCount() * data.m_NumCompsPerLayer );
1180
1181 data.m_Components.reserve( nComps );
1182 for( size_t i = 0; i < nComps; ++i )
1183 {
1184 PADSTACK_COMPONENT& comp = data.m_Components.emplace_back();
1185
1186 comp.m_Type = aStream.ReadU8();
1187
1188 comp.m_UnknownByte1 = aStream.ReadU8();
1189 comp.m_UnknownByte2 = aStream.ReadU8();
1190 comp.m_UnknownByte3 = aStream.ReadU8();
1191
1192 ReadCond( aStream, aVer, comp.m_Unknown1 );
1193
1194 comp.m_W = aStream.ReadS32();
1195 comp.m_H = aStream.ReadS32();
1196
1197 ReadCond( aStream, aVer, comp.m_Z1 );
1198
1199 comp.m_OffsetX = aStream.ReadS32();
1200 comp.m_OffsetY = aStream.ReadS32();
1201
1202 if( aVer >= FMT_VER::V_172 )
1203 {
1204 comp.m_Z2 = aStream.ReadU32();
1205 comp.m_ShapePtr = aStream.ReadU32();
1206 }
1207 else
1208 {
1209 comp.m_ShapePtr = aStream.ReadU32();
1210
1211 if(i < nComps - 1)
1212 comp.m_Z2 = aStream.ReadU32();
1213 }
1214 }
1215
1216 {
1217 const size_t nElems = data.m_N * ( ( aVer < FMT_VER::V_172 ) ? 8 : 10 );
1218
1219 data.m_UnknownArrN.reserve( nElems );
1220 for( size_t i = 0; i < nElems; ++i )
1221 {
1222 data.m_UnknownArrN.push_back( aStream.ReadU32() );
1223 }
1224 }
1225
1226 return block;
1227}
1228
1229
1230static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1D( FILE_STREAM& aStream, FMT_VER aVer )
1231{
1232 auto block = std::make_unique<BLOCK<BLK_0x1D_CONSTRAINT_SET>>( aStream.Position() );
1233
1234 auto& data = block->GetData();
1235
1236 aStream.Skip( 3 );
1237
1238 data.m_Key = aStream.ReadU32();
1239 block->SetKey( data.m_Key );
1240 data.m_Next = aStream.ReadU32();
1241 block->SetNext( data.m_Next );
1242 data.m_NameStrKey = aStream.ReadU32();
1243 data.m_FieldPtr = aStream.ReadU32();
1244
1245 data.m_SizeA = aStream.ReadU16();
1246 data.m_SizeB = aStream.ReadU16();
1247
1248 data.m_DataB.resize( data.m_SizeB );
1249
1250 // This version stores 12 values per copper layer where later ones store 14
1251 const size_t layerRecordSize = aVer == FMT_VER::V_161 ? 48 : sizeof( data.m_DataB[0] );
1252
1253 for( auto& item : data.m_DataB )
1254 {
1255 item.fill( 0 );
1256 aStream.ReadBytes( item.data(), layerRecordSize );
1257 }
1258
1259 data.m_DataA.resize( data.m_SizeA );
1260
1261 for( auto& item : data.m_DataA )
1262 aStream.ReadBytes( item.data(), item.size() );
1263
1264 ReadCond( aStream, aVer, data.m_Unknown4 );
1265
1266 return block;
1267}
1268
1269
1270static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1E( FILE_STREAM& aStream, FMT_VER aVer )
1271{
1272 auto block = std::make_unique<BLOCK<BLK_0x1E_SI_MODEL>>( aStream.Position() );
1273
1274 auto& data = block->GetData();
1275
1276 data.m_Type = aStream.ReadU8();
1277 data.m_T2 = aStream.ReadU16();
1278 data.m_Key = aStream.ReadU32();
1279 block->SetKey( data.m_Key );
1280 data.m_Next = aStream.ReadU32();
1281 block->SetNext( data.m_Next );
1282
1283 ReadCond( aStream, aVer, data.m_Unknown2 );
1284 ReadCond( aStream, aVer, data.m_Unknown3 );
1285
1286 data.m_StrPtr = aStream.ReadU32();
1287 data.m_Size = aStream.ReadU32();
1288
1289 data.m_String = aStream.ReadStringFixed( data.m_Size, true );
1290
1291 ReadCond( aStream, aVer, data.m_Unknown4 );
1292
1293 return block;
1294}
1295
1296
1297static std::unique_ptr<BLOCK_BASE> ParseBlock_0x1F( FILE_STREAM& aStream, FMT_VER aVer )
1298{
1299 auto block = std::make_unique<BLOCK<BLK_0x1F_PADSTACK_DIM>>( aStream.Position() );
1300
1301 auto& data = block->GetData();
1302
1303 aStream.Skip( 3 );
1304
1305 data.m_Key = aStream.ReadU32();
1306 block->SetKey( data.m_Key );
1307
1308 data.m_Next = aStream.ReadU32();
1309 block->SetNext( data.m_Next );
1310 data.m_Unknown2 = aStream.ReadU32();
1311 data.m_Unknown3 = aStream.ReadU32();
1312 data.m_Unknown4 = aStream.ReadU32();
1313 data.m_Unknown5 = aStream.ReadU16();
1314
1315 data.m_Size = aStream.ReadU16();
1316
1317 size_t substructSize = 0;
1318 if( aVer >= FMT_VER::V_175 )
1319 substructSize = data.m_Size * 384 + 8;
1320 else if( aVer >= FMT_VER::V_172 )
1321 substructSize = data.m_Size * 280 + 8;
1322 else if( aVer >= FMT_VER::V_162 )
1323 substructSize = data.m_Size * 280 + 4;
1324 else
1325 substructSize = data.m_Size * 240 + 4;
1326
1327 data.m_Substruct.resize( substructSize );
1328 aStream.ReadBytes( data.m_Substruct.data(), substructSize );
1329
1330 return block;
1331}
1332
1333
1334static std::unique_ptr<BLOCK_BASE> ParseBlock_0x20( FILE_STREAM& aStream, FMT_VER aVer )
1335{
1336 auto block = std::make_unique<BLOCK<BLK_0x20_UNKNOWN>>( aStream.Position() );
1337
1338 auto& data = block->GetData();
1339
1340 data.m_Type = aStream.ReadU8();
1341 data.m_R = aStream.ReadU16();
1342 data.m_Key = aStream.ReadU32();
1343 block->SetKey( data.m_Key );
1344 data.m_Next = aStream.ReadU32();
1345 block->SetNext( data.m_Next );
1346
1347 ReadArrayU32( aStream, data.m_UnknownArray1 );
1348 ReadCond( aStream, aVer, data.m_UnknownArray2 );
1349
1350 return block;
1351}
1352
1353
1354static std::unique_ptr<BLOCK_BASE> ParseBlock_0x21( FILE_STREAM& aStream, FMT_VER aVer )
1355{
1356 auto block = std::make_unique<BLOCK<BLK_0x21_BLOB>>( aStream.Position() );
1357
1358 auto& data = block->GetData();
1359
1360 data.m_Type = aStream.ReadU8();
1361 data.m_R = aStream.ReadU16();
1362
1363 data.m_Size = aStream.ReadU32();
1364
1365 if( data.m_Size < 12 )
1366 {
1367 THROW_IO_ERRORF( wxT( "Block 0x21 size %u too small (minimum 12) at offset %#010zx" ),
1368 data.m_Size, aStream.Position() );
1369 }
1370
1371 data.m_Key = aStream.ReadU32();
1372 block->SetKey( data.m_Key );
1373
1374 const size_t nBytes = data.m_Size - 12;
1375 data.m_Data.resize( nBytes );
1376 aStream.ReadBytes( data.m_Data.data(), nBytes );
1377
1378 return block;
1379}
1380
1381
1382static std::unique_ptr<BLOCK_BASE> ParseBlock_0x22( FILE_STREAM& aStream, FMT_VER aVer )
1383{
1384 auto block = std::make_unique<BLOCK<BLK_0x22_UNKNOWN>>( aStream.Position() );
1385
1386 auto& data = block->GetData();
1387
1388 data.m_Type = aStream.ReadU8();
1389 data.m_T2 = aStream.ReadU16();
1390 data.m_Key = aStream.ReadU32();
1391 block->SetKey( data.m_Key );
1392
1393 ReadCond( aStream, aVer, data.m_Unknown1 );
1394
1395 ReadArrayU32( aStream, data.m_UnknownArray );
1396
1397 return block;
1398}
1399
1400
1401static std::unique_ptr<BLOCK_BASE> ParseBlock_0x23_RATLINE( FILE_STREAM& aStream, FMT_VER aVer )
1402{
1403 auto block = std::make_unique<BLOCK<BLK_0x23_RATLINE>>( aStream.Position() );
1404
1405 auto& data = block->GetData();
1406
1407 data.m_Type = aStream.ReadU8();
1408 data.m_Layer = ParseLayerInfo( aStream );
1409 data.m_Key = aStream.ReadU32();
1410 block->SetKey( data.m_Key );
1411 data.m_Next = aStream.ReadU32();
1412 block->SetNext( data.m_Next );
1413
1414 ReadArrayU32( aStream, data.m_Flags );
1415
1416 data.m_Ptr1 = aStream.ReadU32();
1417 data.m_Ptr2 = aStream.ReadU32();
1418 data.m_Ptr3 = aStream.ReadU32();
1419
1420 for( size_t i = 0; i < data.m_Coords.size(); ++i )
1421 {
1422 data.m_Coords[i] = aStream.ReadS32();
1423 }
1424
1425 ReadArrayU32( aStream, data.m_Unknown1 );
1426
1427 ReadCond( aStream, aVer, data.m_Unknown2 );
1428 ReadCond( aStream, aVer, data.m_Unknown3 );
1429
1430 return block;
1431}
1432
1433
1434static std::unique_ptr<BLOCK_BASE> ParseBlock_0x24_RECT( FILE_STREAM& aStream, FMT_VER aVer )
1435{
1436 auto block = std::make_unique<BLOCK<BLK_0x24_RECT>>( aStream.Position() );
1437
1438 auto& data = block->GetData();
1439
1440 data.m_Type = aStream.ReadU8();
1441 data.m_Layer = ParseLayerInfo( aStream );
1442 data.m_Key = aStream.ReadU32();
1443 block->SetKey( data.m_Key );
1444 data.m_Next = aStream.ReadU32();
1445 block->SetNext( data.m_Next );
1446 data.m_Parent = aStream.ReadU32();
1447 data.m_Unknown1 = aStream.ReadU32();
1448
1449 ReadCond( aStream, aVer, data.m_Unknown2 );
1450
1451 for( size_t i = 0; i < data.m_Coords.size(); ++i )
1452 {
1453 data.m_Coords[i] = aStream.ReadS32();
1454 }
1455
1456 data.m_Ptr2 = aStream.ReadU32();
1457
1458 data.m_Unknown3 = aStream.ReadU32();
1459 data.m_Unknown4 = aStream.ReadU32();
1460 data.m_Rotation = aStream.ReadU32();
1461
1462 return block;
1463}
1464
1465
1466static std::unique_ptr<BLOCK_BASE> ParseBlock_0x26( FILE_STREAM& aStream, FMT_VER aVer )
1467{
1468 auto block = std::make_unique<BLOCK<BLK_0x26_MATCH_GROUP>>( aStream.Position() );
1469
1470 auto& data = block->GetData();
1471
1472 data.m_Type = aStream.ReadU8();
1473 data.m_R = aStream.ReadU16();
1474 data.m_Key = aStream.ReadU32();
1475 block->SetKey( data.m_Key );
1476 data.m_MemberPtr = aStream.ReadU32();
1477
1478 ReadCond( aStream, aVer, data.m_Unknown1 );
1479
1480 data.m_GroupPtr = aStream.ReadU32();
1481 data.m_ConstPtr = aStream.ReadU32();
1482
1483 ReadCond( aStream, aVer, data.m_Unknown2 );
1484
1485 return block;
1486}
1487
1488
1489static std::unique_ptr<BLOCK_BASE> ParseBlock_0x27( FILE_STREAM& aStream, FMT_VER aVer, size_t aEndOff )
1490{
1491 auto block = std::make_unique<BLOCK<BLK_0x27_CSTRMGR_XREF>>( aStream.Position() );
1492
1493 auto& data = block->GetData();
1494
1495 const size_t totalBytes = aEndOff - 1 - aStream.Position();
1496
1497 // The blob starts with 3 bytes of padding, then uint32 LE values
1498 constexpr size_t kPadding = 3;
1499
1500 if( totalBytes <= kPadding )
1501 {
1502 aStream.Skip( totalBytes );
1503 return block;
1504 }
1505
1506 aStream.Skip( kPadding );
1507
1508 const size_t payloadBytes = totalBytes - kPadding;
1509 const size_t numValues = payloadBytes / 4;
1510 const size_t remainder = payloadBytes % 4;
1511
1512 data.m_Refs.resize( numValues );
1513
1514 for( size_t i = 0; i < numValues; i++ )
1515 data.m_Refs[i] = aStream.ReadU32();
1516
1517 if( remainder > 0 )
1518 aStream.Skip( remainder );
1519
1520 return block;
1521}
1522
1523
1524static std::unique_ptr<BLOCK_BASE> ParseBlock_0x28_SHAPE( FILE_STREAM& aStream, FMT_VER aVer )
1525{
1526 auto block = std::make_unique<BLOCK<BLK_0x28_SHAPE>>( aStream.Position() );
1527
1528 auto& data = block->GetData();
1529
1530 data.m_Type = aStream.ReadU8();
1531 data.m_Layer = ParseLayerInfo( aStream );
1532 data.m_Key = aStream.ReadU32();
1533 block->SetKey( data.m_Key );
1534 data.m_Next = aStream.ReadU32();
1535 block->SetNext( data.m_Next );
1536 data.m_Ptr1 = aStream.ReadU32();
1537 data.m_Unknown1 = aStream.ReadU32();
1538
1539 ReadCond( aStream, aVer, data.m_Unknown2 );
1540 ReadCond( aStream, aVer, data.m_Unknown3 );
1541
1542 data.m_Ptr2 = aStream.ReadU32();
1543 data.m_Ptr3 = aStream.ReadU32();
1544 data.m_FirstKeepoutPtr = aStream.ReadU32();
1545 data.m_FirstSegmentPtr = aStream.ReadU32();
1546 data.m_Unknown4 = aStream.ReadU32();
1547 data.m_Unknown5 = aStream.ReadU32();
1548
1549 ReadCond( aStream, aVer, data.m_TablePtr );
1550
1551 data.m_Ptr6 = aStream.ReadU32();
1552
1553 ReadCond( aStream, aVer, data.m_TablePtr_16x );
1554
1555 for( size_t i = 0; i < data.m_Coords.size(); ++i )
1556 {
1557 data.m_Coords[i] = aStream.ReadS32();
1558 }
1559
1560 return block;
1561}
1562
1563
1564static std::unique_ptr<BLOCK_BASE> ParseBlock_0x29_PIN( FILE_STREAM& aStream, FMT_VER aVer )
1565{
1566 auto block = std::make_unique<BLOCK<BLK_0x29_PIN>>( aStream.Position() );
1567
1568 auto& data = block->GetData();
1569
1570 data.m_Type = aStream.ReadU8();
1571 data.m_T = aStream.ReadU16();
1572 data.m_Key = aStream.ReadU32();
1573 block->SetKey( data.m_Key );
1574
1575 data.m_Ptr1 = aStream.ReadU32();
1576 data.m_Ptr2 = aStream.ReadU32();
1577
1578 data.m_Null = aStream.ReadU32();
1579
1580 data.m_Ptr3 = aStream.ReadU32();
1581
1582 data.m_Coord1 = aStream.ReadS32();
1583 data.m_Coord2 = aStream.ReadS32();
1584
1585 data.m_PtrPadstack = aStream.ReadU32();
1586
1587 data.m_Unknown1 = aStream.ReadU32();
1588
1589 data.m_PtrX30 = aStream.ReadU32();
1590
1591 data.m_Unknown2 = aStream.ReadU32();
1592 data.m_Unknown3 = aStream.ReadU32();
1593 data.m_Unknown4 = aStream.ReadU32();
1594
1595 return block;
1596}
1597
1598
1599static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2A( FILE_STREAM& aStream, FMT_VER aVer )
1600{
1601 auto block = std::make_unique<BLOCK<BLK_0x2A_LAYER_LIST>>( aStream.Position() );
1602
1603 auto& data = block->GetData();
1604
1605 aStream.Skip( 1 );
1606
1607 data.m_NumEntries = aStream.ReadU16();
1608
1609 ReadCond( aStream, aVer, data.m_Unknown );
1610
1611 if( data.m_NonRefEntries.exists( aVer ) )
1612 {
1613 data.m_NonRefEntries = std::vector<BLK_0x2A_LAYER_LIST::NONREF_ENTRY>();
1614 data.m_NonRefEntries->reserve( data.m_NumEntries );
1615 for( size_t i = 0; i < data.m_NumEntries; ++i )
1616 {
1617 BLK_0x2A_LAYER_LIST::NONREF_ENTRY& entry = data.m_NonRefEntries->emplace_back();
1618
1619 entry.m_Name = aStream.ReadStringFixed( 32, true );
1620 entry.m_Properties = aStream.ReadU32();
1621 }
1622 }
1623 else
1624 {
1625 data.m_RefEntries = std::vector<BLK_0x2A_LAYER_LIST::REF_ENTRY>();
1626 data.m_RefEntries->reserve( data.m_NumEntries );
1627 for( size_t i = 0; i < data.m_NumEntries; ++i )
1628 {
1629 BLK_0x2A_LAYER_LIST::REF_ENTRY& entry = data.m_RefEntries->emplace_back();
1630
1631 entry.mLayerNameId = aStream.ReadU32();
1632 entry.m_Properties = aStream.ReadU32();
1633 entry.m_Unknown = aStream.ReadU32();
1634 }
1635 }
1636
1637 data.m_Key = aStream.ReadU32();
1638 block->SetKey( data.m_Key );
1639
1640 return block;
1641}
1642
1643
1644static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2B( FILE_STREAM& stream, FMT_VER aVer )
1645{
1646 auto block = std::make_unique<BLOCK<BLK_0x2B_FOOTPRINT_DEF>>( stream.Position() );
1647
1648 auto& data = block->GetData();
1649
1650 stream.Skip( 3 );
1651
1652 data.m_Key = stream.ReadU32();
1653 block->SetKey( data.m_Key );
1654 data.m_FpStrRef = stream.ReadU32();
1655 data.m_Unknown1 = stream.ReadU32();
1656 ReadArrayU32( stream, data.m_Coords );
1657 data.m_Next = stream.ReadU32();
1658 block->SetNext( data.m_Next );
1659 data.m_FirstInstPtr = stream.ReadU32();
1660 data.m_UnknownPtr3 = stream.ReadU32();
1661 data.m_UnknownPtr4 = stream.ReadU32();
1662 data.m_UnknownPtr5 = stream.ReadU32();
1663 data.m_FieldsPtr = stream.ReadU32();
1664 data.m_UnknownPtr6 = stream.ReadU32();
1665 data.m_UnknownPtr7 = stream.ReadU32();
1666 data.m_UnknownPtr8 = stream.ReadU32();
1667
1668 ReadCond( stream, aVer, data.m_Unknown2 );
1669 ReadCond( stream, aVer, data.m_Unknown3 );
1670
1671 return block;
1672}
1673
1674
1675static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2C_TABLE( FILE_STREAM& aStream, FMT_VER aVer )
1676{
1677 auto block = std::make_unique<BLOCK<BLK_0x2C_TABLE>>( aStream.Position() );
1678
1679 auto& data = block->GetData();
1680
1681 data.m_Type = aStream.ReadU8();
1682 data.m_SubType = aStream.ReadU16();
1683 data.m_Key = aStream.ReadU32();
1684 block->SetKey( data.m_Key );
1685 data.m_Next = aStream.ReadU32();
1686 block->SetNext( data.m_Next );
1687
1688 ReadCond( aStream, aVer, data.m_Unknown1 );
1689 ReadCond( aStream, aVer, data.m_Unknown2 );
1690 ReadCond( aStream, aVer, data.m_Unknown3 );
1691
1692 data.m_StringPtr = aStream.ReadU32();
1693
1694 ReadCond( aStream, aVer, data.m_Unknown4 );
1695
1696 data.m_Ptr1 = aStream.ReadU32();
1697 data.m_Ptr2 = aStream.ReadU32();
1698 data.m_Ptr3 = aStream.ReadU32();
1699
1700 data.m_Flags = aStream.ReadU32();
1701
1702 return block;
1703}
1704
1705
1706static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2D( FILE_STREAM& stream, FMT_VER aVer )
1707{
1708 auto block = std::make_unique<BLOCK<BLK_0x2D_FOOTPRINT_INST>>( stream.Position() );
1709
1710 auto& data = block->GetData();
1711
1712 data.m_UnknownByte1 = stream.ReadU8();
1713 data.m_Layer = stream.ReadU8();
1714 data.m_UnknownByte2 = stream.ReadU8();
1715
1716 data.m_Key = stream.ReadU32();
1717 block->SetKey( data.m_Key );
1718 data.m_Next = stream.ReadU32();
1719 block->SetNext( data.m_Next );
1720
1721 ReadCond( stream, aVer, data.m_Unknown1 );
1722
1723 ReadCond( stream, aVer, data.m_InstRef16x );
1724
1725 data.m_Unknown2 = stream.ReadU16();
1726 data.m_Unknown3 = stream.ReadU16();
1727
1728 ReadCond( stream, aVer, data.m_Unknown4 );
1729
1730 data.m_Flags = stream.ReadU32();
1731
1732 data.m_Rotation = stream.ReadU32();
1733 data.m_CoordX = stream.ReadS32();
1734 data.m_CoordY = stream.ReadS32();
1735
1736 ReadCond( stream, aVer, data.m_InstRef );
1737
1738 data.m_GraphicPtr = stream.ReadU32();
1739 data.m_FirstPadPtr = stream.ReadU32();
1740 data.m_TextPtr = stream.ReadU32();
1741
1742 data.m_AssemblyPtr = stream.ReadU32();
1743 data.m_AreasPtr = stream.ReadU32();
1744 data.m_UnknownPtr1 = stream.ReadU32();
1745 data.m_UnknownPtr2 = stream.ReadU32();
1746
1747 return block;
1748}
1749
1750
1751static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2E( FILE_STREAM& aStream, FMT_VER aVer )
1752{
1753 auto block = std::make_unique<BLOCK<BLK_0x2E_CONNECTION>>( aStream.Position() );
1754
1755 auto& data = block->GetData();
1756
1757 data.m_Type = aStream.ReadU8();
1758 data.m_T2 = aStream.ReadU16();
1759 data.m_Key = aStream.ReadU32();
1760 block->SetKey( data.m_Key );
1761 data.m_Next = aStream.ReadU32();
1762 block->SetNext( data.m_Next );
1763 data.m_NetAssignment = aStream.ReadU32();
1764 data.m_Unknown1 = aStream.ReadU32();
1765 data.m_CoordX = aStream.ReadU32();
1766 data.m_CoordY = aStream.ReadU32();
1767 data.m_Connection = aStream.ReadU32();
1768 data.m_Unknown2 = aStream.ReadU32();
1769
1770 ReadCond( aStream, aVer, data.m_Unknown3 );
1771
1772 return block;
1773}
1774
1775
1776static std::unique_ptr<BLOCK_BASE> ParseBlock_0x2F( FILE_STREAM& aStream, FMT_VER aVer )
1777{
1778 auto block = std::make_unique<BLOCK<BLK_0x2F_UNKNOWN>>( aStream.Position() );
1779
1780 auto& data = block->GetData();
1781
1782 data.m_Type = aStream.ReadU8();
1783 data.m_T2 = aStream.ReadU16();
1784 data.m_Key = aStream.ReadU32();
1785 block->SetKey( data.m_Key );
1786
1787 ReadArrayU32( aStream, data.m_UnknownArray );
1788
1789 return block;
1790}
1791
1792
1794{
1796
1797 props.m_Key = aStream.ReadU8();
1798 props.m_Flags = aStream.ReadU8();
1799
1800 uint8_t alignment = aStream.ReadU8();
1801 switch( alignment )
1802 {
1806 case 0x1a:
1807 default:
1809 // THROW_IO_ERROR( wxString::Format( "Unknown text alignment value: %#02x", alignment ) );
1810 }
1811
1812 uint8_t reversal = aStream.ReadU8();
1813 switch( reversal )
1814 {
1818 case 0x0c:
1819 default:
1821 //THROW_IO_ERROR( wxString::Format( "Unknown text reversal value: %#02x", reversal ) );
1822 }
1823 return props;
1824}
1825
1826
1827static std::unique_ptr<BLOCK_BASE> ParseBlock_0x30_STR_WRAPPER( FILE_STREAM& aStream, FMT_VER aVer )
1828{
1829 auto block = std::make_unique<BLOCK<BLK_0x30_STR_WRAPPER>>( aStream.Position() );
1830
1831 auto& data = block->GetData();
1832
1833 data.m_Type = aStream.ReadU8();
1834 data.m_Layer = ParseLayerInfo( aStream );
1835 data.m_Key = aStream.ReadU32();
1836 block->SetKey( data.m_Key );
1837 data.m_Next = aStream.ReadU32();
1838 block->SetNext( data.m_Next );
1839
1840 ReadCond( aStream, aVer, data.m_Unknown1 );
1841 ReadCond( aStream, aVer, data.m_Unknown2 );
1842
1843 if( data.m_Font.exists( aVer ) )
1844 {
1845 data.m_Font = ParseTextProps( aStream );
1846 }
1847
1848 ReadCond( aStream, aVer, data.m_Ptr1 );
1849 ReadCond( aStream, aVer, data.m_Unknown3 );
1850
1851 data.m_StrGraphicPtr = aStream.ReadU32();
1852
1853 ReadCond( aStream, aVer, data.m_PtrGroup_17x );
1854 ReadCond( aStream, aVer, data.m_Unknown4 );
1855
1856 if( data.m_Font16x.exists( aVer ) )
1857 {
1858 data.m_Font16x = ParseTextProps( aStream );
1859 }
1860
1861 ReadCond( aStream, aVer, data.m_Ptr2 );
1862
1863 data.m_CoordsX = aStream.ReadU32();
1864 data.m_CoordsY = aStream.ReadU32();
1865
1866 data.m_Unknown5 = aStream.ReadU32();
1867 data.m_Rotation = aStream.ReadU32();
1868
1869 ReadCond( aStream, aVer, data.m_PtrGroup_16x );
1870 ReadCond( aStream, aVer, data.m_Ptr0x3E_V181 );
1871
1872 return block;
1873}
1874
1875
1876static std::unique_ptr<BLOCK_BASE> ParseBlock_0x31_SGRAPHIC( FILE_STREAM& aStream, FMT_VER aVer )
1877{
1878 auto block = std::make_unique<BLOCK<BLK_0x31_SGRAPHIC>>( aStream.Position() );
1879
1880 auto& data = block->GetData();
1881
1882 data.m_T = aStream.ReadU8();
1883
1884 {
1885 const uint16_t layer = aStream.ReadU16();
1886
1887 switch( layer )
1888 {
1889 case 0xF001: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::BOT_TEXT; break;
1890 case 0xF101: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::TOP_TEXT; break;
1891 case 0xF609: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::BOT_PIN; break;
1892 case 0xF709: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::TOP_PIN; break;
1893 case 0xF801: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::TOP_PIN_LABEL; break;
1894 case 0xFA0D: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::BOT_REFDES; break;
1895 case 0xFB0D: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::TOP_REFDES; break;
1896 default: data.m_Layer = BLK_0x31_SGRAPHIC::STRING_LAYER::UNKNOWN; break;
1897 }
1898 }
1899
1900 data.m_Key = aStream.ReadU32();
1901 block->SetKey( data.m_Key );
1902 data.m_StrGraphicWrapperPtr = aStream.ReadU32();
1903
1904 data.m_CoordsX = aStream.ReadU32();
1905 data.m_CoordsY = aStream.ReadU32();
1906
1907 data.m_Unknown = aStream.ReadU16();
1908 data.m_Len = aStream.ReadU16();
1909
1910 ReadCond( aStream, aVer, data.m_Un2 );
1911
1912 data.m_Value = aStream.ReadStringFixed( data.m_Len, true );
1913
1914 return block;
1915}
1916
1917
1918static std::unique_ptr<BLOCK_BASE> ParseBlock_0x32_PLACED_PAD( FILE_STREAM& aStream, FMT_VER aVer )
1919{
1920 auto block = std::make_unique<BLOCK<BLK_0x32_PLACED_PAD>>( aStream.Position() );
1921
1922 auto& data = block->GetData();
1923
1924 data.m_Type = aStream.ReadU8();
1925 data.m_Layer = ParseLayerInfo( aStream );
1926 data.m_Key = aStream.ReadU32();
1927 block->SetKey( data.m_Key );
1928 data.m_Next = aStream.ReadU32();
1929 block->SetNext( data.m_Next );
1930 data.m_NetPtr = aStream.ReadU32();
1931 data.m_Flags = aStream.ReadU32();
1932
1933 ReadCond( aStream, aVer, data.m_Prev );
1934
1935 data.m_NextInFp = aStream.ReadU32();
1936 data.m_ParentFp = aStream.ReadU32();
1937 data.m_Track = aStream.ReadU32();
1938 data.m_PadPtr = aStream.ReadU32();
1939 data.m_Ptr6 = aStream.ReadU32();
1940 data.m_Ratline = aStream.ReadU32();
1941 data.m_PtrPinNumber = aStream.ReadU32();
1942 data.m_NextInCompInst = aStream.ReadU32();
1943
1944 ReadCond( aStream, aVer, data.m_Unknown2 );
1945
1946 data.m_NameText = aStream.ReadU32();
1947 data.m_Ptr11 = aStream.ReadU32();
1948
1949 for( size_t i = 0; i < data.m_Coords.size(); ++i )
1950 {
1951 data.m_Coords[i] = aStream.ReadS32();
1952 }
1953
1954 return block;
1955}
1956
1957
1958static std::unique_ptr<BLOCK_BASE> ParseBlock_0x33_VIA( FILE_STREAM& aStream, FMT_VER aVer )
1959{
1960 auto block = std::make_unique<BLOCK<BLK_0x33_VIA>>( aStream.Position() );
1961
1962 auto& data = block->GetData();
1963
1964 aStream.Skip( 1 );
1965
1966 data.m_LayerInfo = ParseLayerInfo( aStream );
1967 data.m_Key = aStream.ReadU32();
1968 block->SetKey( data.m_Key );
1969 data.m_Next = aStream.ReadU32();
1970 block->SetNext( data.m_Next );
1971 data.m_NetPtr = aStream.ReadU32();
1972 data.m_Unknown2 = aStream.ReadU32();
1973
1974 ReadCond( aStream, aVer, data.m_Unknown3 );
1975
1976 data.m_UnknownPtr1 = aStream.ReadU32();
1977
1978 ReadCond( aStream, aVer, data.m_UnknownPtr2 );
1979
1980 data.m_CoordsX = aStream.ReadS32();
1981 data.m_CoordsY = aStream.ReadS32();
1982
1983 data.m_Connection = aStream.ReadU32();
1984 data.m_Padstack = aStream.ReadU32();
1985 data.m_UnknownPtr5 = aStream.ReadU32();
1986 data.m_UnknownPtr6 = aStream.ReadU32();
1987
1988 data.m_Unknown4 = aStream.ReadU32();
1989 data.m_Unknown5 = aStream.ReadU32();
1990
1991 for( size_t i = 0; i < data.m_BoundingBoxCoords.size(); ++i )
1992 {
1993 data.m_BoundingBoxCoords[i] = aStream.ReadS32();
1994 }
1995
1996 return block;
1997}
1998
1999
2000static std::unique_ptr<BLOCK_BASE> ParseBlock_0x34_KEEPOUT( FILE_STREAM& aStream, FMT_VER aVer )
2001{
2002 auto block = std::make_unique<BLOCK<BLK_0x34_KEEPOUT>>( aStream.Position() );
2003
2004 auto& data = block->GetData();
2005
2006 data.m_T = aStream.ReadU8();
2007 data.m_Layer = ParseLayerInfo( aStream );
2008 data.m_Key = aStream.ReadU32();
2009 block->SetKey( data.m_Key );
2010 data.m_Next = aStream.ReadU32();
2011 block->SetNext( data.m_Next );
2012 data.m_Ptr1 = aStream.ReadU32();
2013
2014 ReadCond( aStream, aVer, data.m_Unknown1 );
2015
2016 data.m_Flags = aStream.ReadU32();
2017 data.m_FirstSegmentPtr = aStream.ReadU32();
2018 data.m_Ptr3 = aStream.ReadU32();
2019 data.m_Unknown2 = aStream.ReadU32();
2020
2021 return block;
2022}
2023
2024
2025static std::unique_ptr<BLOCK_BASE> ParseBlock_0x35( FILE_STREAM& aStream, FMT_VER aVer )
2026{
2027 auto block = std::make_unique<BLOCK<BLK_0x35_FILE_REF>>( aStream.Position() );
2028
2029 auto& data = block->GetData();
2030
2031 data.m_T2 = aStream.ReadU8();
2032 data.m_T3 = aStream.ReadU16();
2033
2034 data.m_Next = aStream.ReadU32();
2035 block->SetNext( data.m_Next );
2036
2037 data.m_Unknown1 = aStream.ReadU32();
2038
2039 aStream.ReadBytes( data.m_LogFile.data(), data.m_LogFile.size() );
2040
2041 data.m_Unknown2 = aStream.ReadU32();
2042
2043 aStream.ReadBytes( data.m_UnusedFile.data(), data.m_UnusedFile.size() );
2044 aStream.ReadBytes( data.m_EclReportFile.data(), data.m_EclReportFile.size() );
2045 aStream.ReadBytes( data.m_EclLogFile.data(), data.m_EclLogFile.size() );
2046
2047 data.m_Unknown3 = aStream.ReadU32();
2048
2049 aStream.ReadBytes( data.m_Version.data(), data.m_Version.size() );
2050
2051 data.m_Unknown4 = aStream.ReadU32();
2052 data.m_Unknown5 = aStream.ReadU32();
2053 data.m_Unknown6 = aStream.ReadU32();
2054
2055 data.m_Key = aStream.ReadU32();
2056 block->SetKey( data.m_Key );
2057
2058 return block;
2059}
2060
2061
2062static std::unique_ptr<BLOCK_BASE> ParseBlock_0x36( FILE_STREAM& aStream, FMT_VER aVer )
2063{
2064 auto block = std::make_unique<BLOCK<BLK_0x36_DEF_TABLE>>( aStream.Position() );
2065
2066 auto& data = block->GetData();
2067
2068 aStream.Skip( 1 );
2069
2070 data.m_Code = aStream.ReadU16();
2071 data.m_Key = aStream.ReadU32();
2072 block->SetKey( data.m_Key );
2073 data.m_Next = aStream.ReadU32();
2074 block->SetNext( data.m_Next );
2075
2076 ReadCond( aStream, aVer, data.m_Unknown1 );
2077
2078 data.m_NumItems = aStream.ReadU32();
2079 data.m_Count = aStream.ReadU32();
2080 data.m_LastIdx = aStream.ReadU32();
2081 data.m_Unknown2 = aStream.ReadU32();
2082
2083 ReadCond( aStream, aVer, data.m_Unknown3 );
2084
2085 if( data.m_NumItems > 1000000 )
2086 {
2087 THROW_IO_ERRORF( wxT( "Block 0x36 item count %u exceeds limit at offset %#010zx" ),
2088 data.m_NumItems,
2089 aStream.Position() );
2090 }
2091
2092 if( data.m_Count > data.m_NumItems )
2093 {
2094 THROW_IO_ERRORF( wxT( "Block 0x36 filled count %u exceeds capacity %u at offset %#010zx" ),
2095 data.m_Count,
2096 data.m_NumItems,
2097 aStream.Position() );
2098 }
2099
2100 // Each block has m_NumItems slots but only the first m_Count are populated; the rest are
2101 // zeroes. Iterate all slots to stride across them correctly, but only keep the
2102 // actual existing items.
2103 data.m_Items.reserve( data.m_Count );
2104 for( uint32_t i = 0; i < data.m_NumItems; ++i )
2105 {
2106 const bool keep = i < data.m_Count;
2107
2108 switch( data.m_Code )
2109 {
2110 case 0x02:
2111 {
2113
2114 item.m_String = aStream.ReadStringFixed( 32, true );
2115 ReadArrayU32( aStream, item.m_Xs );
2116 ReadCond( aStream, aVer, item.m_Ys );
2117 ReadCond( aStream, aVer, item.m_Zs );
2118
2119 if( keep )
2120 data.m_Items.emplace_back( std::move( item ) );
2121 break;
2122 }
2123 case 0x03:
2124 {
2126 if( aVer >= FMT_VER::V_172 )
2127 item.m_Str = aStream.ReadStringFixed( 64, true );
2128 else
2129 item.m_Str16x = aStream.ReadStringFixed( 32, true );
2130
2131 ReadCond( aStream, aVer, item.m_Unknown1 );
2132
2133 if( keep )
2134 data.m_Items.emplace_back( std::move( item ) );
2135 break;
2136 }
2137 case 0x05:
2138 {
2140
2141 aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2142 ReadCond( aStream, aVer, item.m_Unknown2 );
2143
2144 if( keep )
2145 data.m_Items.emplace_back( std::move( item ) );
2146 break;
2147 }
2148 case 0x06:
2149 {
2151
2152 item.m_N = aStream.ReadU16();
2153 item.m_R = aStream.ReadU8();
2154 item.m_S = aStream.ReadU8();
2155 item.m_Unknown1 = aStream.ReadU32();
2156
2157 ReadCond( aStream, aVer, item.m_Unknown2 );
2158
2159 if( keep )
2160 data.m_Items.emplace_back( std::move( item ) );
2161 break;
2162 }
2163 case 0x08:
2164 {
2166
2167 item.m_A = aStream.ReadU32();
2168 item.m_B = aStream.ReadU32();
2169 item.m_CharHeight = aStream.ReadU32();
2170 item.m_CharWidth = aStream.ReadU32();
2171
2172 ReadCond( aStream, aVer, item.m_Unknown2 );
2173
2174 item.m_CharacterSpace = aStream.ReadU32();
2175 item.m_LineSpace = aStream.ReadU32();
2176 item.m_Unknown3 = aStream.ReadU32();
2177 item.m_StrokeWidth = aStream.ReadU32();
2178
2179 ReadCond( aStream, aVer, item.m_Ys );
2180
2181 if( keep )
2182 data.m_Items.emplace_back( std::move( item ) );
2183 break;
2184 }
2185 case 0x0B:
2186 {
2188 aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2189 if( keep )
2190 data.m_Items.emplace_back( std::move( item ) );
2191 break;
2192 }
2193 case 0x0C:
2194 {
2196 aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2197 if( keep )
2198 data.m_Items.emplace_back( std::move( item ) );
2199 break;
2200 }
2201 case 0x0D:
2202 {
2204 aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2205 if( keep )
2206 data.m_Items.emplace_back( std::move( item ) );
2207 break;
2208 }
2209 case 0x0F:
2210 {
2212 item.m_Key = aStream.ReadU32();
2213 ReadArrayU32( aStream, item.m_Ptrs );
2214 item.m_Ptr2 = aStream.ReadU32();
2215
2216 if( keep )
2217 data.m_Items.emplace_back( std::move( item ) );
2218
2219 break;
2220 }
2221 case 0x10:
2222 {
2224 aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2225 ReadCond( aStream, aVer, item.m_Unknown2 );
2226
2227 if( keep )
2228 data.m_Items.emplace_back( std::move( item ) );
2229
2230 break;
2231 }
2232 case 0x12:
2233 {
2235 // aStream.ReadBytes( item.m_Unknown.data(), item.m_Unknown.size() );
2236 aStream.Skip( 1052 );
2237
2238 if( keep )
2239 data.m_Items.emplace_back( std::move( item ) );
2240
2241 break;
2242 }
2243 default: THROW_IO_ERRORF( wxT( "Unknown substruct type %#02x in block 0x36" ), data.m_Code );
2244 }
2245 }
2246
2247 return block;
2248}
2249
2250
2251static std::unique_ptr<BLOCK_BASE> ParseBlock_0x37( FILE_STREAM& aStream, FMT_VER aVer )
2252{
2253 auto block = std::make_unique<BLOCK<BLK_0x37_PTR_ARRAY>>( aStream.Position() );
2254
2255 auto& data = block->GetData();
2256
2257 data.m_T = aStream.ReadU8();
2258 data.m_T2 = aStream.ReadU16();
2259 data.m_Key = aStream.ReadU32();
2260 block->SetKey( data.m_Key );
2261 data.m_GroupPtr = aStream.ReadU32();
2262 data.m_Next = aStream.ReadU32();
2263 block->SetNext( data.m_Next );
2264 data.m_Capacity = aStream.ReadU32();
2265 data.m_Count = aStream.ReadU32();
2266 data.m_Unknown2 = aStream.ReadU32();
2267
2268 ReadCond( aStream, aVer, data.m_Unknown3 );
2269
2270 // The table is m_Capacity entries long. m_Count indicates how many entries are valid.
2271 // But we read all of them.
2272
2273 // Defend against a mis-parse that would index beyond the end of the file
2274 const size_t maxCapacity = ( aStream.Size() - aStream.Position() ) / sizeof( uint32_t );
2275
2276 if( data.m_Capacity > maxCapacity )
2277 {
2278 THROW_IO_ERRORF( wxT( "Block 0x37 capacity %u exceeds the %zu entries left in the file at offset %#010zx" ),
2279 data.m_Capacity, maxCapacity, aStream.Position() );
2280 }
2281
2282 if( data.m_Count > data.m_Capacity )
2283 {
2284 THROW_IO_ERRORF( wxT( "Block 0x37 count %u exceeds capacity %u at offset %#010zx" ),
2285 data.m_Count, data.m_Capacity, aStream.Position() );
2286 }
2287
2288 data.m_Ptrs.resize( data.m_Capacity );
2289 ReadArrayU32( aStream, data.m_Ptrs );
2290
2291 return block;
2292}
2293
2294
2295static std::unique_ptr<BLOCK_BASE> ParseBlock_0x38_FILM( FILE_STREAM& aStream, FMT_VER aVer )
2296{
2297 auto block = std::make_unique<BLOCK<BLK_0x38_FILM>>( aStream.Position() );
2298
2299 auto& data = block->GetData();
2300
2301 aStream.Skip( 3 );
2302
2303 data.m_Key = aStream.ReadU32();
2304 block->SetKey( data.m_Key );
2305 data.m_Next = aStream.ReadU32();
2306 block->SetNext( data.m_Next );
2307 data.m_LayerList = aStream.ReadU32();
2308
2309 if( data.m_FilmName.exists( aVer ) )
2310 {
2311 data.m_FilmName = aStream.ReadStringFixed( 20, true );
2312 }
2313
2314 ReadCond( aStream, aVer, data.m_LayerNameStr );
2315 ReadCond( aStream, aVer, data.m_Unknown2 );
2316
2317 for( size_t i = 0; i < data.m_UnknownArray1.size(); ++i )
2318 {
2319 data.m_UnknownArray1[i] = aStream.ReadU32();
2320 }
2321
2322 ReadCond( aStream, aVer, data.m_Unknown3 );
2323
2324 return block;
2325}
2326
2327
2328static std::unique_ptr<BLOCK_BASE> ParseBlock_0x39_FILM_LAYER_LIST( FILE_STREAM& aStream, FMT_VER aVer )
2329{
2330 auto block = std::make_unique<BLOCK<BLK_0x39_FILM_LAYER_LIST>>( aStream.Position() );
2331
2332 auto& data = block->GetData();
2333
2334 aStream.Skip( 3 );
2335
2336 data.m_Key = aStream.ReadU32();
2337 block->SetKey( data.m_Key );
2338 data.m_Parent = aStream.ReadU32();
2339 data.m_Head = aStream.ReadU32();
2340
2341 for( size_t i = 0; i < data.m_X.size(); ++i )
2342 {
2343 data.m_X[i] = aStream.ReadU16();
2344 }
2345
2346 return block;
2347}
2348
2349
2350static std::unique_ptr<BLOCK_BASE> ParseBlock_0x3A_FILM_LIST_NODE( FILE_STREAM& aStream, FMT_VER aVer )
2351{
2352 auto block = std::make_unique<BLOCK<BLK_0x3A_FILM_LIST_NODE>>( aStream.Position() );
2353
2354 auto& data = block->GetData();
2355
2356 aStream.Skip( 1 );
2357
2358 data.m_Layer = ParseLayerInfo( aStream );
2359 data.m_Key = aStream.ReadU32();
2360 block->SetKey( data.m_Key );
2361 data.m_Next = aStream.ReadU32();
2362 block->SetNext( data.m_Next );
2363 data.m_Unknown = aStream.ReadU32();
2364
2365 ReadCond( aStream, aVer, data.m_Unknown1 );
2366
2367 return block;
2368}
2369
2370
2371static std::unique_ptr<BLOCK_BASE> ParseBlock_0x3B( FILE_STREAM& aStream, FMT_VER aVer )
2372{
2373 auto block = std::make_unique<BLOCK<BLK_0x3B_PROPERTY>>( aStream.Position() );
2374
2375 auto& data = block->GetData();
2376
2377 data.m_T = aStream.ReadU8();
2378 data.m_SubType = aStream.ReadU16();
2379 data.m_Len = aStream.ReadU32();
2380
2381 data.m_Name = aStream.ReadStringFixed( 128, true );
2382 data.m_Type = aStream.ReadStringFixed( 32, true );
2383
2384 data.m_Unknown1 = aStream.ReadU32();
2385 data.m_Unknown2 = aStream.ReadU32();
2386
2387 ReadCond( aStream, aVer, data.m_Unknown3 );
2388
2389 data.m_Value = aStream.ReadStringFixed( data.m_Len, true );
2390
2391 return block;
2392}
2393
2394
2395static std::unique_ptr<BLOCK_BASE> ParseBlock_0x3E( FILE_STREAM& aStream, FMT_VER aVer )
2396{
2397 auto block = std::make_unique<BLOCK<BLK_0x3E>>( aStream.Position() );
2398
2399 auto& data = block->GetData();
2400
2401 aStream.Skip( 3 );
2402
2403 data.m_Key = aStream.ReadU32();
2404 block->SetKey( data.m_Key );
2405
2406 for( uint32_t& word : data.m_Unknown )
2407 word = aStream.ReadU32();
2408
2409 return block;
2410}
2411
2412
2413static std::unique_ptr<BLOCK_BASE> ParseBlock_0x3C( FILE_STREAM& aStream, FMT_VER aVer )
2414{
2415 auto block = std::make_unique<BLOCK<BLK_0x3C_KEY_LIST>>( aStream.Position() );
2416
2417 auto& data = block->GetData();
2418
2419 data.m_T = aStream.ReadU8();
2420 data.m_T2 = aStream.ReadU16();
2421 data.m_Key = aStream.ReadU32();
2422 block->SetKey( data.m_Key );
2423
2424 ReadCond( aStream, aVer, data.m_Unknown );
2425
2426 data.m_NumEntries = aStream.ReadU32();
2427
2428 if( data.m_NumEntries > 1000000 )
2429 {
2430 THROW_IO_ERRORF( wxT( "Block 0x3C entry count %u exceeds limit at offset %#010zx" ),
2431 data.m_NumEntries,
2432 aStream.Position() );
2433 }
2434
2435 data.m_Entries.reserve( data.m_NumEntries );
2436
2437 for( uint32_t i = 0; i < data.m_NumEntries; ++i )
2438 data.m_Entries.push_back( aStream.ReadU32() );
2439
2440 return block;
2441}
2442
2443
2444std::unique_ptr<BLOCK_BASE> ALLEGRO::BLOCK_PARSER::ParseBlock( bool& aEndOfObjectsMarker )
2445{
2446 // Read the type of the object
2447 // The file can end here without error.
2448 uint8_t type = 0x00;
2449 if( !m_stream.GetU8( type ) )
2450 {
2451 aEndOfObjectsMarker = true;
2452 return nullptr;
2453 }
2454
2455 std::unique_ptr<BLOCK_BASE> block;
2456
2457 switch( type )
2458 {
2459 case 0x01:
2460 {
2462 break;
2463 }
2464 case 0x03:
2465 {
2466 block = ParseBlock_0x03( m_stream, m_ver );
2467 break;
2468 }
2469 case 0x04:
2470 {
2472 break;
2473 }
2474 case 0x05:
2475 {
2477 break;
2478 }
2479 case 0x06:
2480 {
2481 block = ParseBlock_0x06( m_stream, m_ver );
2482 break;
2483 }
2484 case 0x07:
2485 {
2486 block = ParseBlock_0x07( m_stream, m_ver );
2487 break;
2488 }
2489 case 0x08:
2490 {
2491 block = ParseBlock_0x08( m_stream, m_ver );
2492 break;
2493 }
2494 case 0x09:
2495 {
2496 block = ParseBlock_0x09( m_stream, m_ver );
2497 break;
2498 }
2499 case 0x0A:
2500 {
2502 break;
2503 }
2504 case 0x0C:
2505 {
2506 block = ParseBlock_0x0C( m_stream, m_ver );
2507 break;
2508 }
2509 case 0x0D:
2510 {
2512 break;
2513 }
2514 case 0x0E:
2515 {
2516 block = ParseBlock_0x0E( m_stream, m_ver );
2517 break;
2518 }
2519 case 0x0F:
2520 {
2521 block = ParseBlock_0x0F( m_stream, m_ver );
2522 break;
2523 }
2524 case 0x10:
2525 {
2526 block = ParseBlock_0x10( m_stream, m_ver );
2527 break;
2528 }
2529 case 0x11:
2530 {
2531 block = ParseBlock_0x11( m_stream, m_ver );
2532 break;
2533 }
2534 case 0x12:
2535 {
2536 block = ParseBlock_0x12( m_stream, m_ver );
2537 break;
2538 }
2539 case 0x14:
2540 {
2541 block = ParseBlock_0x14( m_stream, m_ver );
2542 break;
2543 }
2544 case 0x15:
2545 case 0x16:
2546 case 0x17:
2547 {
2549 break;
2550 }
2551 case 0x1A:
2552 {
2553 block = ParseBlock_0x1A( m_stream, m_ver );
2554 break;
2555 }
2556 case 0x1B:
2557 {
2559 break;
2560 }
2561 case 0x1C:
2562 {
2564 break;
2565 }
2566 case 0x1D:
2567 {
2568 block = ParseBlock_0x1D( m_stream, m_ver );
2569 break;
2570 }
2571 case 0x1E:
2572 {
2573 block = ParseBlock_0x1E( m_stream, m_ver );
2574 break;
2575 }
2576 case 0x1F:
2577 {
2578 block = ParseBlock_0x1F( m_stream, m_ver );
2579 break;
2580 }
2581 case 0x20:
2582 {
2583 block = ParseBlock_0x20( m_stream, m_ver );
2584 break;
2585 }
2586 case 0x21:
2587 {
2588 block = ParseBlock_0x21( m_stream, m_ver );
2589 break;
2590 }
2591 case 0x22:
2592 {
2593 block = ParseBlock_0x22( m_stream, m_ver );
2594 break;
2595 }
2596 case 0x23:
2597 {
2599 break;
2600 }
2601 case 0x24:
2602 {
2604 break;
2605 }
2606 case 0x26:
2607 {
2608 block = ParseBlock_0x26( m_stream, m_ver );
2609 break;
2610 }
2611 case 0x27:
2612 {
2613 if( m_x27_end <= m_stream.Position() )
2614 {
2615 THROW_IO_ERRORF( wxT( "Current offset %#010zx is at or past the expected end of block 0x27 at %#010zx" ),
2616 m_stream.Position(), m_x27_end );
2617 }
2618
2620 break;
2621 }
2622 case 0x28:
2623 {
2625 break;
2626 }
2627 case 0x29:
2628 {
2630 break;
2631 }
2632 case 0x2A:
2633 {
2634 block = ParseBlock_0x2A( m_stream, m_ver );
2635 break;
2636 }
2637 case 0x2B:
2638 {
2639 block = ParseBlock_0x2B( m_stream, m_ver );
2640 break;
2641 }
2642 case 0x2C:
2643 {
2645 break;
2646 }
2647 case 0x2D:
2648 {
2649 block = ParseBlock_0x2D( m_stream, m_ver );
2650 break;
2651 }
2652 case 0x2E:
2653 {
2654 block = ParseBlock_0x2E( m_stream, m_ver );
2655 break;
2656 }
2657 case 0x2F:
2658 {
2659 block = ParseBlock_0x2F( m_stream, m_ver );
2660 break;
2661 }
2662 case 0x30:
2663 {
2665 break;
2666 }
2667 case 0x31:
2668 {
2670 break;
2671 }
2672 case 0x32:
2673 {
2675 break;
2676 }
2677 case 0x33:
2678 {
2680 break;
2681 }
2682 case 0x34:
2683 {
2685 break;
2686 }
2687 case 0x35:
2688 {
2689 block = ParseBlock_0x35( m_stream, m_ver );
2690 break;
2691 }
2692 case 0x36:
2693 {
2694 block = ParseBlock_0x36( m_stream, m_ver );
2695 break;
2696 }
2697 case 0x37:
2698 {
2699 block = ParseBlock_0x37( m_stream, m_ver );
2700 break;
2701 }
2702 case 0x38:
2703 {
2705 break;
2706 }
2707 case 0x39:
2708 {
2710 break;
2711 }
2712 case 0x3A:
2713 {
2715 break;
2716 }
2717 case 0x3B:
2718 {
2719 block = ParseBlock_0x3B( m_stream, m_ver );
2720 break;
2721 }
2722 case 0x3C:
2723 {
2724 block = ParseBlock_0x3C( m_stream, m_ver );
2725 break;
2726 }
2727 case 0x3E:
2728 {
2729 block = ParseBlock_0x3E( m_stream, m_ver );
2730 break;
2731 }
2732 case 0x00:
2733 {
2734 // A 0x00 type byte is not a block.
2735 // It's only "real" if the rest of the file is zero padding, otherwise
2736 // it's probably an error in the previous block's length.
2737 aEndOfObjectsMarker = true;
2738 break;
2739 }
2740 default:
2741 break;
2742 }
2743
2744 return block;
2745}
2746
2747
2749{
2750 const FMT_VER ver = aBoard.m_FmtVer;
2751
2752 if( m_progressReporter )
2753 {
2754 m_progressReporter->AdvancePhase( _( "Parsing Allegro objects" ) );
2755 // This isn't exactly the number we seem to parse, but it's very close
2756 m_progressReporter->SetMaxProgress( static_cast<int>( aBoard.m_Header->m_ObjectCount ) );
2757 }
2758
2759 BLOCK_PARSER blockParser( m_stream, ver, aBoard.m_Header->Get_0x27_End() );
2760
2761 THROTTLE refreshThrottle( std::chrono::milliseconds( 100 ) );
2762
2763 while( true )
2764 {
2765 const size_t offset = m_stream.Position();
2766
2767 // Peek at the block type byte before ParseBlock consumes it so we
2768 // have the value available for error messages if the type is unknown
2769 // and ParseBlock returns nullptr.
2770 uint8_t blockTypeByte = 0;
2771 m_stream.GetU8( blockTypeByte );
2772 m_stream.Seek( offset );
2773
2774 // This seems to be always true and is quite useful for debugging out-of-sync
2775 // objects with non-zero type tags.
2776 if( blockTypeByte != 0x00 )
2777 {
2778 wxASSERT_MSG( offset % 4 == 0,
2779 wxString::Format( "Allegro object at %#010zx, offset not aligned to 4 bytes",
2780 offset ) );
2781 }
2782
2783 bool endOfObjectsMarker = false;
2784 std::unique_ptr<BLOCK_BASE> block = blockParser.ParseBlock( endOfObjectsMarker );
2785
2786 if( endOfObjectsMarker )
2787 {
2788 // Everything from here has to be zero padding. Anything else means an earlier
2789 // block was parsed into the wrong length, and ending the stream would junk
2790 // real content after the presumed end of objects.
2791 const size_t zeroRunStart = m_stream.Position();
2792
2793 while( !m_stream.Eof() )
2794 {
2795 const size_t zeroOffset = m_stream.Position();
2796 const uint8_t zeroValue = m_stream.ReadU8();
2797
2798 if( zeroValue != 0x00 )
2799 {
2800 THROW_IO_ERRORF( wxT( "Expected only zero padding to the end of the file after the " )
2801 wxT( "zero type byte at offset %#010zx, but found %#02x at offset " )
2802 wxT( "%#010zx, at object index %zu of %u" ),
2803 offset, zeroValue, zeroOffset, aBoard.GetObjectCount(),
2804 aBoard.m_Header->m_ObjectCount );
2805 }
2806 }
2807
2808 if( wxLog::IsAllowedTraceMask( traceAllegroParser ) )
2809 {
2810 wxLogTrace( traceAllegroParser,
2811 wxString::Format( "End of objects at index %zu, offset %#010zx, "
2812 "%zu bytes of zero padding to the end of the file",
2813 aBoard.GetObjectCount(), offset,
2814 m_stream.Size() - zeroRunStart ) );
2815 }
2816
2817 break;
2818 }
2819
2820 if( !block )
2821 {
2822 if( !m_endAtUnknownBlock )
2823 {
2824 THROW_IO_ERRORF( wxT( "Do not have parser for block index %zu type %#02x available at offset %#010zx" ),
2825 aBoard.GetObjectCount() + 1,
2826 blockTypeByte,
2827 offset );
2828 }
2829 else
2830 {
2831 wxLogTrace( traceAllegroParser,
2832 wxString::Format( "Ending at unknown block, index %zu type %#04x at offset %#010zx",
2833 aBoard.GetObjectCount(), blockTypeByte, offset ) );
2834
2835 wxFAIL_MSG( "Failed to create block" );
2836 return;
2837 }
2838 }
2839 else
2840 {
2841 wxLogTrace( traceAllegroParserBlocks,
2842 wxString::Format( "Added block %zu, type %#04x from %#010zx to %#010zx",
2843 aBoard.GetObjectCount(), block->GetBlockType(), offset,
2844 m_stream.Position() ) );
2845
2846 aBoard.InsertBlock( std::move( block ) );
2847
2848 if( m_progressReporter )
2849 {
2850 m_progressReporter->AdvanceProgress();
2851
2852 if( ( aBoard.GetObjectCount() & 0x3F ) == 0 && refreshThrottle.Ready() )
2853 m_progressReporter->KeepRefreshing();
2854 }
2855 }
2856 }
2857}
2858
2859
2860template <typename T>
2861void dumpLL( const char* name, const T& aLL )
2862{
2863 if constexpr( std::is_same_v<T, FILE_HEADER::LINKED_LIST> )
2864 {
2865 wxLogTrace( traceAllegroParser, " LL %-20s head=%#010x tail=%#010x", name, aLL.m_Head, aLL.m_Tail );
2866 }
2867 else if constexpr( VERSIONED_COND_FIELD<T> && std::is_same_v<typename T::value_type, FILE_HEADER::LINKED_LIST> )
2868 {
2869 if( aLL.has_value() )
2870 dumpLL( name, aLL.value() );
2871 }
2872}
2873
2874
2875std::unique_ptr<BRD_DB> ALLEGRO::PARSER::Parse()
2876{
2877 std::unique_ptr<BRD_DB> board = std::make_unique<BRD_DB>();
2878
2879 if( m_progressReporter )
2880 {
2881 m_progressReporter->AddPhases( 2 );
2882 m_progressReporter->AdvancePhase( "Reading file header" );
2883 }
2884
2885 PROF_TIMER parseTimer;
2886 HEADER_PARSER headerParser( m_stream );
2887
2888 try
2889 {
2890 board->m_Header = headerParser.ParseHeader();
2891
2892 if( !board->m_Header )
2893 THROW_IO_ERROR( wxT( "Failed to parse file header" ) );
2894
2895 board->m_FmtVer = headerParser.GetFormatVersion();
2896
2897 {
2898 wxLogTrace( traceAllegroParser, "Header linked lists (ver=%#010x):", board->m_Header->m_Magic );
2899
2900 dumpLL( "0x04", board->m_Header->m_LL_0x04 );
2901 dumpLL( "0x06", board->m_Header->m_LL_0x06 );
2902 dumpLL( "0x0C", board->m_Header->m_LL_0x0C );
2903 dumpLL( "Shapes", board->m_Header->m_LL_Shapes );
2904 dumpLL( "0x14", board->m_Header->m_LL_0x14 );
2905 dumpLL( "0x1B_Nets", board->m_Header->m_LL_0x1B_Nets );
2906 dumpLL( "0x1C", board->m_Header->m_LL_0x1C );
2907 dumpLL( "0x24_0x28", board->m_Header->m_LL_0x24_0x28 );
2908 dumpLL( "Unknown1", board->m_Header->m_LL_Unknown1 );
2909 dumpLL( "0x2B", board->m_Header->m_LL_0x2B );
2910 dumpLL( "0x03_0x30", board->m_Header->m_LL_0x03_0x30 );
2911 dumpLL( "0x0A", board->m_Header->m_LL_0x0A );
2912 dumpLL( "0x1D_0x1E_0x1F", board->m_Header->m_LL_0x1D_0x1E_0x1F );
2913 dumpLL( "Unknown2", board->m_Header->m_LL_Unknown2 );
2914 dumpLL( "0x38", board->m_Header->m_LL_0x38 );
2915 dumpLL( "0x2C", board->m_Header->m_LL_0x2C );
2916 dumpLL( "0x0C_2", board->m_Header->m_LL_0x0C_2 );
2917 dumpLL( "Unknown3", board->m_Header->m_LL_Unknown3 );
2918
2919 dumpLL( "0x35", board->m_Header->m_LL_0x35 );
2920 dumpLL( "0x36", board->m_Header->m_LL_0x36 );
2921 dumpLL( "Unknown4", board->m_Header->m_LL_Unknown4 );
2922 dumpLL( "Unknown5", board->m_Header->m_LL_Unknown5 );
2923 dumpLL( "0x0A_2", board->m_Header->m_LL_0x0A_2 );
2924
2925 dumpLL( "0x03_2", board->m_Header->m_LL_0x03_2 );
2926
2927 wxLogTrace( traceAllegroParser, " LL trailing word %#010x",
2928 board->m_Header->m_Unknown_LlTrailer );
2929 }
2930 }
2931 catch( const IO_ERROR& e )
2932 {
2933 wxString s;
2934 s += wxString::Format( "Error parsing Allegro file: %s\n", e.What() );
2935 s += wxString::Format( "Stream position: %#010lx\n", m_stream.Position() );
2936
2937 if( board->m_Header )
2938 s += wxString::Format( "File magic: %#010x\n", board->m_Header->m_Magic );
2939 else
2940 s += wxString::Format( "File magic: Unknown\n" );
2941
2942 THROW_IO_ERROR( s );
2943 }
2944
2945 wxLogTrace( traceAllegroPerf, wxT( " ReadHeader: %.3f ms" ), parseTimer.msecs( true ) ); //format:allow
2946
2947 if( board->m_FmtVer == FMT_VER::V_PRE_V16 )
2948 {
2949 wxString verStr( board->m_Header->m_AllegroVersion.data(), 60 );
2950 verStr.Trim();
2951
2952 THROW_IO_ERRORF( _( "This file was created with %s, which uses a binary format that predates Allegro 16.0 "
2953 "and is not supported by this importer.\n\n"
2954 "To import this design, open it in Cadence Allegro PCB Editor version 16.0 or later "
2955 "and re-save, then import the resulting file." ), verStr );
2956 }
2957
2958 const uint32_t stringsCount = board->m_Header->GetStringsCount();
2959 board->ReserveCapacity( board->m_Header->m_ObjectCount, stringsCount, m_stream.Size() );
2960
2961 try
2962 {
2963 ReadStringMap( m_stream, *board, stringsCount );
2964
2965 wxLogTrace( traceAllegroPerf, wxT( " ReadStringMap (%u strings): %.3f ms" ), //format:allow
2966 stringsCount, parseTimer.msecs( true ) );
2967
2968 readObjects( *board );
2969
2970 wxLogTrace( traceAllegroPerf, wxT( " readObjects (%zu objects): %.3f ms" ), //format:allow
2971 board->GetObjectCount(), parseTimer.msecs( true ) );
2972 }
2973 catch( const IO_ERROR& e )
2974 {
2975 wxString s;
2976 s += wxString::Format( "Error parsing Allegro file: %s\n", e.What() );
2977 s += wxString::Format( "Stream position: %#010lx\n", m_stream.Position() );
2978
2979 if( board->m_Header )
2980 s += wxString::Format( "File magic: %#010x\n", board->m_Header->m_Magic );
2981 else
2982 s += wxString::Format( "File magic: Unknown\n" );
2983
2984 THROW_IO_ERROR( s );
2985 }
2986
2987 wxLogTrace( traceAllegroPerf, wxT( " Phase 1 total: %.3f ms" ), parseTimer.msecs() ); //format:allow
2988
2989 return board;
2990}
const char * name
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x35(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x36(FILE_STREAM &aStream, FMT_VER aVer)
void dumpLL(const char *name, const T &aLL)
static PAD_TYPE decodePadType(uint8_t aVal)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x04_NET_ASSIGNMENT(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2C_TABLE(FILE_STREAM &aStream, FMT_VER aVer)
static void ReadStringMap(FILE_STREAM &stream, BRD_DB &aDb, uint32_t count)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1F(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x3A_FILM_LIST_NODE(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x3C(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x14(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x08(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x10(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1B_NET(FILE_STREAM &stream, FMT_VER aVer)
static const wxChar *const traceAllegroParserBlocks
static FILE_HEADER::LINKED_LIST ReadLL(FILE_STREAM &aStream)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x0F(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x05_TRACK(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1D(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1C_PADSTACK(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x34_KEEPOUT(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x01_ARC(FILE_STREAM &aStream, FMT_VER aVer)
static BLK_0x30_STR_WRAPPER::TEXT_PROPERTIES ParseTextProps(FILE_STREAM &aStream)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x0D_PAD(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1E(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x20(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x0A_DRC(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x06(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x0E(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x1A(FILE_STREAM &aStream, FMT_VER aVer)
static void ReadArrayU32(FILE_STREAM &aStream, ARRAY &aArray)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x39_FILM_LAYER_LIST(FILE_STREAM &aStream, FMT_VER aVer)
static void ReadCond(FILE_STREAM &aStream, FMT_VER aFmtVer, COND_T &aField)
Read a single conditional field from the stream, if it exists at the current version.
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x09(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x38_FILM(FILE_STREAM &aStream, FMT_VER aVer)
static double ReadAllegroFloat(FILE_STREAM &aStream)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x24_RECT(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2E(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x03(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x12(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x15_16_17_SEGMENT(FILE_STREAM &aStream, FMT_VER aVer, uint8_t aType)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x31_SGRAPHIC(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x22(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x27(FILE_STREAM &aStream, FMT_VER aVer, size_t aEndOff)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2A(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2F(FILE_STREAM &aStream, FMT_VER aVer)
static LAYER_INFO ParseLayerInfo(FILE_STREAM &aStream)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x07(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x33_VIA(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x32_PLACED_PAD(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x37(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2B(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x2D(FILE_STREAM &stream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x21(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x23_RATLINE(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x28_SHAPE(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x11(FILE_STREAM &aStream, FMT_VER aVer)
static T ReadField(FILE_STREAM &aStream)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x26(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x3B(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x0C(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x29_PIN(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x3E(FILE_STREAM &aStream, FMT_VER aVer)
static std::unique_ptr< BLOCK_BASE > ParseBlock_0x30_STR_WRAPPER(FILE_STREAM &aStream, FMT_VER aVer)
The block parser is responsible for parsing individual blocks of data from the file stream.
std::unique_ptr< BLOCK_BASE > ParseBlock(bool &aEndOfObjectsMarker)
Parse one block from the stream, returning a BLOCK_BASE representing the raw data of the block.
const size_t m_x27_end
To parse an 0x27 block, we need to know where the end of the block is in the stream.
An Allegro board database representing the contents of a .brd (and presumably .dra) file.
Definition allegro_db.h:42
FMT_VER m_FmtVer
Definition allegro_db.h:84
std::unique_ptr< FILE_HEADER > m_Header
Definition allegro_db.h:85
size_t GetObjectCount() const
Definition allegro_db.h:51
void InsertBlock(std::unique_ptr< BLOCK_BASE > aBlock)
void AddString(uint32_t aKey, wxString &&aStr)
Definition allegro_db.h:46
Stream that reads primitive types from a memory buffer containing Allegro .brd (or ....
size_t Size() const
void ReadBytes(void *aDest, size_t aSize)
Read a number of bytes from the stream into the destination buffer.
void Skip(size_t aBytes)
size_t Position() const
std::string ReadString(bool aRoundToNextU32)
void Seek(size_t aPos)
std::string ReadStringFixed(size_t aLen, bool aRoundToNextU32)
Parses a .brd header, taking care of any version-specific differences.
std::unique_ptr< FILE_HEADER > ParseHeader()
FMT_VER GetFormatVersion() const
Get the parsed format version.
static FMT_VER FormatFromMagic(uint32_t aMagic)
Determine the format version from the magic number.
PROGRESS_REPORTER * m_progressReporter
void readObjects(BRD_DB &aDb)
FILE_STREAM & m_stream
std::unique_ptr< BRD_DB > Parse()
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()
A small class to help profiling.
Definition profile.h:46
double msecs(bool aSinceLast=false)
Definition profile.h:148
Rate-limiter that fires at most once per interval.
Definition throttle.h:31
bool Ready()
Definition throttle.h:44
#define _(s)
#define THROW_IO_ERROR(msg)
macro which captures the "call site" values of FILE_, __FUNCTION & LINE
#define THROW_IO_ERRORF(msg,...)
static const wxChar *const traceAllegroParser
Flag to enable debug output of Allegro parsing.
PAD_TYPE
The type of the padstack.
FMT_VER
The format of an Allegro file.
static const wxChar *const traceAllegroPerf
std::array< uint32_t, 20 > m_Entries
COND_GE< FMT_VER::V_165, uint32_t > m_Unknown_4
COND_GE< FMT_VER::V_180, std::array< uint32_t, 8 > > m_UnknownArr_v180
uint8_t m_Flags
Mask of PAD_FLAGS values.
std::string m_Name
uint32_t m_Properties
Same layer flags as REF_ENTRY, stored after the 32 byte name.
uint32_t m_Properties
uint32_t m_Unknown
uint32_t mLayerNameId
COND_GE< FMT_VER::V_172, std::array< uint32_t, 8 > > m_Ys
COND_GE_LT< FMT_VER::V_174, FMT_VER::V_190, uint32_t > m_Unknown2
COND_GE< FMT_VER::V_172, std::array< uint32_t, 2 > > m_Zs
COND_GE< FMT_VER::V_164, std::array< uint32_t, 3 > > m_Ys
COND_GE< FMT_VER::V_172, std::string > m_Str
COND_GE< FMT_VER::V_174, uint32_t > m_Unknown1
COND_LT< FMT_VER::V_172, std::string > m_Str16x
std::array< uint8_t, 28 > m_Unknown
COND_GE< FMT_VER::V_175, uint32_t > m_Unknown2
COND_LT< FMT_VER::V_172, std::array< uint32_t, 50 > > m_Unknown2
std::array< uint8_t, 1016 > m_Unknown
std::array< uint8_t, 232 > m_Unknown
std::array< uint8_t, 200 > m_Unknown
std::array< uint8_t, 108 > m_Unknown
COND_GE< FMT_VER::V_180, uint32_t > m_Unknown2
This is apparently some kind of linked list that chains though subsets objects in the file.
Substruct in a padstack object.
A type that is always false.
KIBIS_COMPONENT * comp
wxString result
Test unit parsing edge cases and error handling.