KiCad PCB EDA Suite
Loading...
Searching...
No Matches
rs274x.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 (C) 2007-2018 Jean-Pierre Charras jp.charras at wanadoo.fr
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 2
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, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25
26#include <base_units.h>
27#include <math/util.h> // for KiROUND
28
29#include <gerbview.h>
30#include <gerber_file_image.h>
31#include <core/ignore.h>
32#include <macros.h>
33#include <string_utils.h>
35#include <gbr_metadata.h>
36#include <wx/log.h>
37
38extern int ReadInt( char*& text, bool aSkipSeparator = true );
39extern double ReadDouble( char*& text, bool aSkipSeparator = true );
40
41
42#define CODE( x, y ) ( ( (x) << 8 ) + (y) )
43
44// See rs274xrevd_e.pdf, table 1: RS-274X parameters order of entry
45// in gerber files, when a coordinate is given (like X78Y600 or I0J80):
46// Y and Y are logical coordinates
47// A and B are plotter coordinates
48// Usually A = X, B = Y
49// But we can have A = Y, B = X and/or offset, mirror, scale;
50// Also:
51// Image is what you must plot (the entire data of the file).
52// Layer is just a set of data blocks with their parameters. An image can have more than one
53// layer so a gerber layer is not like a board layer or the graphic layers used in GerbView
54// to show a file.
56 // Directive parameters: single usage recommended
57 // Must be at the beginning of the file
58 AXIS_SELECT = CODE( 'A', 'S' ), // Default: A=X, B=Y
59 FORMAT_STATEMENT = CODE( 'F', 'S' ), // no default: this command must exists
60 MIRROR_IMAGE = CODE( 'M', 'I' ), // Default: mo mirror
61 MODE_OF_UNITS = CODE( 'M', 'O' ), // Default: inch
62 INCH = CODE( 'I', 'N' ),
63 MILLIMETER = CODE( 'M', 'M' ),
64 OFFSET = CODE( 'O', 'F' ), // Default: A = 0, B = 0
65 SCALE_FACTOR = CODE( 'S', 'F' ), // Default: A = 1.0, B = 1.0
66
67 // Image parameters:
68 // commands used only once at the beginning of the file, and are deprecated
69 IMAGE_JUSTIFY = CODE( 'I', 'J' ), // Default: no justification
70 IMAGE_NAME = CODE( 'I', 'N' ), // Default: void
71 IMAGE_OFFSET = CODE( 'I', 'O' ), // Default: A = 0, B = 0
72 IMAGE_POLARITY = CODE( 'I', 'P' ), // Default: Positive
73 IMAGE_ROTATION = CODE( 'I', 'R' ), // Default: 0
74
75 // Aperture parameters:
76 // Usually for the whole file
77 AP_DEFINITION = CODE( 'A', 'D' ),
78 AP_MACRO = CODE( 'A', 'M' ),
79
80 // X2 extension attribute commands
81 // Mainly are found standard attributes and user attributes
82 // standard attributes commands are:
83 // TF (file attribute) TO (net attribute)
84 // TA (aperture attribute) and TD (delete aperture attribute)
85 FILE_ATTRIBUTE = CODE( 'T', 'F' ),
86
87 // X2 extension Net attribute info
88 // Net attribute options are:
89 // TO (net attribute data): TO.CN or TO.P TO.N or TO.C
90 NET_ATTRIBUTE = CODE( 'T', 'O' ),
91
92 // X2 extension Aperture attribute TA
93 APERTURE_ATTRIBUTE = CODE( 'T', 'A' ),
94
95 // TD (delete aperture/object attribute):
96 // Delete aperture attribute added by %TA or Oblect attribute added b %TO
97 // TD (delete all) or %TD<attr name> to delete <attr name>.
98 // eg: TD.P or TD.N or TD.C ...
100
101 // Layer specific parameters
102 // May be used singly or may be layer specific
103 // These parameters are at the beginning of the file or layer
104 // and reset some layer parameters (like interpolation)
105 KNOCKOUT = CODE( 'K', 'O' ), // Default: off
106 STEP_AND_REPEAT = CODE( 'S', 'R' ), // Default: A = 1, B = 1
107 ROTATE = CODE( 'R', 'O' ), // Default: 0
108
109 LOAD_POLARITY = CODE( 'L', 'P' ), //LPC or LPD. Default: Dark (LPD)
110 LOAD_NAME = CODE( 'L', 'N' ), // Deprecated: equivalent to G04
111};
112
113
115{
116 /* reads two bytes of data and assembles them into an int with the first
117 * byte in the sequence put into the most significant part of a 16 bit value
118 */
119 int result;
120 int currbyte;
121
122 if( text && *text )
123 {
124 currbyte = *text++;
125 result = ( currbyte & 0xFF ) << 8;
126 }
127 else
128 return -1;
129
130 if( text && *text )
131 {
132 currbyte = *text++;
133 result += currbyte & 0xFF;
134 }
135 else
136 return -1;
137
138 return result;
139}
140
141
142bool GERBER_FILE_IMAGE::ReadRS274XCommand( char *aBuff, unsigned int aBuffSize, char*& aText )
143{
144 bool ok = true;
145 int code_command;
146
147 aText++;
148
149 for( ; ; )
150 {
151 while( *aText )
152 {
153 switch( *aText )
154 {
155 case '%': // end of command
156 aText++;
158 goto exit; // success completion
159
160 case ' ':
161 case '\r':
162 case '\n':
163 aText++;
164 break;
165
166 case '*':
167 aText++;
168 break;
169
170 default:
171 code_command = ReadXCommandID( aText );
172 ok = ExecuteRS274XCommand( code_command, aBuff, aBuffSize, aText );
173
174 if( !ok )
175 goto exit;
176
177 break;
178 }
179 }
180
181 // end of current line, read another one.
182 if( fgets( aBuff, aBuffSize, m_Current_File ) == nullptr )
183 {
184 // end of file
185 ok = false;
186 break;
187 }
188
189 m_LineNum++;
190 aText = aBuff;
191 }
192
193exit:
194 return ok;
195}
196
197
198bool GERBER_FILE_IMAGE::ExecuteRS274XCommand( int aCommand, char* aBuff,
199 unsigned int aBuffSize, char*& aText )
200{
201 int code;
202 int seq_len; // not used, just provided
203 int seq_char;
204 bool ok = true;
205 wxString msg;
206 double fcoord;
207 bool x_fmt_known = false;
208 bool y_fmt_known = false;
209
210 // conv_scale = scaling factor from inch to Internal Unit
211 double conv_scale = gerbIUScale.IU_PER_MILS * 1000;
212
214
215 if( m_GerbMetric )
216 conv_scale /= 25.4;
217
218 switch( aCommand )
219 {
220 case FORMAT_STATEMENT:
221 seq_len = 2;
222
223 while( *aText != '*' )
224 {
225 switch( *aText )
226 {
227 case ' ':
228 aText++;
229 break;
230
231 case 'D': // Non-standard option for all zeros (leading + tailing)
232 msg.Printf( _( "RS274X: Invalid GERBER format command '%c' at line %d: \"%s\"" ),
233 'D', m_LineNum, aBuff );
234 AddMessageToList( msg );
235 msg.Printf( _("GERBER file \"%s\" may not display as intended." ),
236 m_FileName.ToAscii() );
237 AddMessageToList( msg );
239
240 case 'L': // No Leading 0
241 m_NoTrailingZeros = false;
242 aText++;
243 break;
244
245 case 'T': // No trailing 0
246 m_NoTrailingZeros = true;
247 aText++;
248 break;
249
250 case 'A': // Absolute coord
251 m_Relative = false;
252 aText++;
253 break;
254
255 case 'I': // Relative coord
256 m_Relative = true;
257 aText++;
258 break;
259
260 case 'G':
261 case 'N': // Sequence code (followed by one digit: the sequence len)
262 // (sometimes found before the X,Y sequence)
263 // Obscure option
264 aText++;
265 seq_char = *aText++;
266
267 if( (seq_char >= '0') && (seq_char <= '9') )
268 seq_len = seq_char - '0';
269
270 break;
271
272 case 'M': // Sequence code (followed by one digit: the sequence len)
273 // (sometimes found after the X,Y sequence)
274 // Obscure option
275 aText++;
276 code = *aText;
277
278 if( ( code >= '0' ) && ( code <= '9' ) )
279 aText++; // skip the digit
280
281 break;
282
283 case 'X':
284 case 'Y':
285 {
286 code = *(aText++);
287 char ctmp = *(aText++) - '0';
288
289 if( code == 'X' )
290 {
291 x_fmt_known = true;
292 // number of digits after the decimal point (0 to 7 allowed)
293 m_FmtScale.x = *aText - '0';
294 m_FmtLen.x = ctmp + m_FmtScale.x;
295
296 // m_FmtScale is 0 to 7
297 // (Old Gerber specification was 0 to 6)
298 if( m_FmtScale.x < 0 )
299 m_FmtScale.x = 0;
300
301 if( m_FmtScale.x > 7 )
302 m_FmtScale.x = 7;
303 }
304 else
305 {
306 y_fmt_known = true;
307 m_FmtScale.y = *aText - '0';
308 m_FmtLen.y = ctmp + m_FmtScale.y;
309
310 if( m_FmtScale.y < 0 )
311 m_FmtScale.y = 0;
312
313 if( m_FmtScale.y > 7 )
314 m_FmtScale.y = 7;
315 }
316
317 aText++;
318 break;
319 }
320
321 case '*':
322 break;
323
324 default:
325 msg.Printf( wxT( "Unknown id (%c) in FS command" ), *aText );
326 AddMessageToList( msg );
327 GetEndOfBlock( aBuff, aBuffSize, aText, m_Current_File );
328 ok = false;
329 break;
330 }
331 }
332
333 if( !x_fmt_known || !y_fmt_known )
334 AddMessageToList( wxT( "RS274X: Format Statement (FS) without X or Y format" ) );
335
336 break;
337
338 case AXIS_SELECT: // command ASAXBY*% or %ASAYBX*%
339 m_SwapAxis = false;
340
341 if( strncasecmp( aText, "AYBX", 4 ) == 0 )
342 m_SwapAxis = true;
343
344 break;
345
346 case MIRROR_IMAGE: // command %MIA0B0*%, %MIA0B1*%, %MIA1B0*%, %MIA1B1*%
347 m_MirrorA = m_MirrorB = false;
348
349 while( *aText && *aText != '*' )
350 {
351 switch( *aText )
352 {
353 case 'A': // Mirror A axis ?
354 aText++;
355
356 if( *aText == '1' )
357 m_MirrorA = true;
358
359 break;
360
361 case 'B': // Mirror B axis ?
362 aText++;
363
364 if( *aText == '1' )
365 m_MirrorB = true;
366
367 break;
368
369 default:
370 aText++;
371 break;
372 }
373 }
374 break;
375
376 case MODE_OF_UNITS:
377 code = ReadXCommandID( aText );
378
379 if( code == INCH )
380 m_GerbMetric = false;
381 else if( code == MILLIMETER )
382 m_GerbMetric = true;
383
385 break;
386
387 case FILE_ATTRIBUTE: // Command %TF ...
388 dummy.ParseAttribCmd( m_Current_File, aBuff, aBuffSize, aText, m_LineNum );
389
390 if( dummy.IsFileFunction() )
391 {
392 delete m_FileFunction;
394
395 // Don't set this until we get a file function; other code expects m_IsX2_file == true
396 // to mean that we have a valid m_FileFunction
397 m_IsX2_file = true;
398 }
399 else if( dummy.IsFileMD5() )
400 {
401 m_MD5_value = dummy.GetPrm( 1 );
402 }
403 else if( dummy.IsFilePart() )
404 {
405 m_PartString = dummy.GetPrm( 1 );
406 }
407
408 break;
409
410 case APERTURE_ATTRIBUTE: // Command %TA
411 dummy.ParseAttribCmd( m_Current_File, aBuff, aBuffSize, aText, m_LineNum );
412
413 if( dummy.GetAttribute() == wxT( ".AperFunction" ) )
414 {
415 m_AperFunction = dummy.GetPrm( 1 );
416
417 // A few function values can have other parameters. Add them
418 for( int ii = 2; ii < dummy.GetPrmCount(); ii++ )
419 m_AperFunction << wxT( "," ) << dummy.GetPrm( ii );
420 }
421
422 break;
423
424 case NET_ATTRIBUTE: // Command %TO currently %TO.P %TO.N and %TO.C
425 dummy.ParseAttribCmd( m_Current_File, aBuff, aBuffSize, aText, m_LineNum );
426
427 if( dummy.GetAttribute() == wxT( ".N" ) )
428 {
431 }
432 else if( dummy.GetAttribute() == wxT( ".C" ) )
433 {
436 }
437 else if( dummy.GetAttribute() == wxT( ".P" ) )
438 {
442
443 if( dummy.GetPrmCount() > 3 )
444 {
446 true, true );
447 }
448 else
449 {
451 }
452 }
453
454 break;
455
456 case REMOVE_APERTURE_ATTRIBUTE: // Command %TD ...
457 dummy.ParseAttribCmd( m_Current_File, aBuff, aBuffSize, aText, m_LineNum );
459
460 break;
461
462 case OFFSET: // command: OFAnnBnn (nn = float number) = layer Offset
463 m_Offset.x = m_Offset.y = 0;
464
465 while( *aText != '*' )
466 {
467 switch( *aText )
468 {
469 case 'A': // A axis offset in current unit (inch or mm)
470 aText++;
471 fcoord = ReadDouble( aText );
472 m_Offset.x = KiROUND( fcoord * conv_scale );
473 break;
474
475 case 'B': // B axis offset in current unit (inch or mm)
476 aText++;
477 fcoord = ReadDouble( aText );
478 m_Offset.y = KiROUND( fcoord * conv_scale );
479 break;
480 }
481 }
482
483 break;
484
485 case SCALE_FACTOR:
486 m_Scale.x = m_Scale.y = 1.0;
487
488 while( *aText != '*' )
489 {
490 switch( *aText )
491 {
492 case 'A': // A axis scale
493 aText++;
494 m_Scale.x = ReadDouble( aText );
495 break;
496
497 case 'B': // B axis scale
498 aText++;
499 m_Scale.y = ReadDouble( aText );
500 break;
501 }
502 }
503
504 break;
505
506 case IMAGE_OFFSET: // command: IOAnnBnn (nn = float number) = Image Offset
508
509 while( *aText != '*' )
510 {
511 switch( *aText )
512 {
513 case 'A': // A axis offset in current unit (inch or mm)
514 aText++;
515 fcoord = ReadDouble( aText );
516 m_ImageOffset.x = KiROUND( fcoord * conv_scale );
517 break;
518
519 case 'B': // B axis offset in current unit (inch or mm)
520 aText++;
521 fcoord = ReadDouble( aText );
522 m_ImageOffset.y = KiROUND( fcoord * conv_scale );
523 break;
524 }
525 }
526
527 break;
528
529 case IMAGE_ROTATION: // command IR0* or IR90* or IR180* or IR270*
530 if( strncasecmp( aText, "0*", 2 ) == 0 )
531 m_ImageRotation = 0;
532 else if( strncasecmp( aText, "90*", 3 ) == 0 )
533 m_ImageRotation = 90;
534 else if( strncasecmp( aText, "180*", 4 ) == 0 )
535 m_ImageRotation = 180;
536 else if( strncasecmp( aText, "270*", 4 ) == 0 )
537 m_ImageRotation = 270;
538 else
539 AddMessageToList( _( "RS274X: Command \"IR\" rotation value not allowed" ) );
540
541 break;
542
543 case STEP_AND_REPEAT: // command SR, like %SRX3Y2I5.0J2*%
544 m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
546 GetLayerParams().m_StepForRepeat.x = 0.0; // offset for Step and Repeat command
548 GetLayerParams().m_YRepeatCount = 1; // The repeat count
550
551 while( *aText && *aText != '*' )
552 {
553 switch( *aText )
554 {
555 case 'I': // X axis offset
556 aText++;
558 break;
559
560 case 'J': // Y axis offset
561 aText++;
563 break;
564
565 case 'X': // X axis repeat count
566 aText++;
568 break;
569
570 case 'Y': // Y axis offset
571 aText++;
573 break;
574
575 default:
576 aText++;
577 break;
578 }
579 }
580
581 break;
582
583 case IMAGE_JUSTIFY: // Command IJAnBn*
584 m_ImageJustifyXCenter = false; // Image Justify Center on X axis (default = false)
585 m_ImageJustifyYCenter = false; // Image Justify Center on Y axis (default = false)
586 m_ImageJustifyOffset = VECTOR2I( 0, 0 ); // Image Justify Offset on XY axis (default = 0,0)
587
588 while( *aText && *aText != '*' )
589 {
590 // IJ command is (for A or B axis) AC or AL or A<coordinate>
591 switch( *aText )
592 {
593 case 'A': // A axis justify
594 aText++;
595
596 if( *aText == 'C' )
597 {
599 aText++;
600 }
601 else if( *aText == 'L' )
602 {
604 aText++;
605 }
606 else
607 {
608 m_ImageJustifyOffset.x = KiROUND( ReadDouble( aText ) * conv_scale);
609 }
610
611 break;
612
613 case 'B': // B axis justify
614 aText++;
615
616 if( *aText == 'C' )
617 {
619 aText++;
620 }
621 else if( *aText == 'L' )
622 {
624 aText++;
625 }
626 else
627 {
628 m_ImageJustifyOffset.y = KiROUND( ReadDouble( aText ) * conv_scale);
629 }
630
631 break;
632
633 default:
634 aText++;
635 break;
636 }
637 }
638
641
644
645 break;
646
647 case KNOCKOUT:
648 m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
649 msg = _( "RS274X: Command KNOCKOUT ignored by GerbView" ) ;
650 AddMessageToList( msg );
651 break;
652
653 case ROTATE: // Layer rotation: command like %RO45*%
654 m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
655 m_LocalRotation = ReadDouble( aText ); // Store layer rotation in degrees
656 break;
657
658 case IMAGE_NAME:
659 m_ImageName.Empty();
660
661 while( *aText != '*' )
662 m_ImageName.Append( *aText++ );
663
664 break;
665
666 case LOAD_NAME:
667 // %LN is a (deprecated) equivalentto G04: a comment
668 while( *aText && *aText != '*' )
669 aText++; // Skip text
670
671 break;
672
673 case IMAGE_POLARITY:
674 // These commands are deprecated since 2012.
675 // So do nothing and prompt the user about this command
676 if( strncasecmp( aText, "NEG", 3 ) == 0 )
677 {
678 m_ImageNegative = true;
679 // IPPOS Gerber command is deprecated since 2012.
680 // in Gerber doc 2024, the advice is: warn user and skip it.
681 AddMessageToList( _( "IPNEG Gerber command is deprecated since 2012. Skip it" ) );
682 }
683 else
684 {
685 m_ImageNegative = false;
686 // IPPOS Gerber command is deprecated since 2012.
687 // However this is the default for a Gerber file, and does not have
688 // actual effect. Just skip it.
689 }
690
691 ok = false;
692 break;
693
694 case LOAD_POLARITY:
695 if( *aText == 'C' )
697 else
699
700 break;
701
702 case AP_MACRO: // lines like %AMMYMACRO*
703 // 5,1,8,0,0,1.08239X$1,22.5*
704 // %
705 /*ok = */ReadApertureMacro( aBuff, aBuffSize, aText, m_Current_File );
706 break;
707
708 case AP_DEFINITION:
709 /* input example: %ADD30R,0.081800X0.101500*%
710 * Aperture definition has 4 options: C, R, O, P
711 * (Circle, Rect, Oval, regular Polygon)
712 * and shapes can have a hole (round or rectangular).
713 * All optional parameters values start by X
714 * at this point, text points to 2nd 'D'
715 */
716 if( *aText++ != 'D' )
717 {
718 ok = false;
719 break;
720 }
721
722 m_Has_DCode = true;
723
724 code = ReadInt( aText );
725
726 D_CODE* dcode;
727 dcode = GetDCODEOrCreate( code );
728
729 if( dcode == nullptr )
730 break;
731
733
734 // at this point, text points to character after the ADD<num>,
735 // i.e. R in example above. If aText[0] is one of the usual
736 // apertures: (C,R,O,P), there is a comma after it.
737 if( aText[1] == ',' )
738 {
739 char stdAperture = *aText;
740
741 aText += 2; // skip "C," for example
742
743 // First parameter is the size X:
744 dcode->m_Size.x = KiROUND( ReadDouble( aText ) * conv_scale );
745 dcode->m_Size.y = dcode->m_Size.x;
746
747 switch( stdAperture ) // Aperture desceiption has optional parameters. Read them
748 {
749 case 'C': // Circle
750 dcode->m_ApertType = APT_CIRCLE;
751 while( *aText == ' ' )
752 aText++;
753
754 if( *aText == 'X' )
755 {
756 aText++;
757 dcode->m_Drill.x = dcode->m_Drill.y =
758 KiROUND( ReadDouble( aText ) * conv_scale );
760 }
761
762 while( *aText == ' ' )
763 aText++;
764
765 if( *aText == 'X' )
766 {
767 aText++;
768 dcode->m_Drill.y =
769 KiROUND( ReadDouble( aText ) * conv_scale );
770
772 }
773
774 dcode->m_Defined = true;
775 break;
776
777 case 'O': // oval
778 case 'R': // rect
779 dcode->m_ApertType = (stdAperture == 'O') ? APT_OVAL : APT_RECT;
780
781 while( *aText == ' ' )
782 aText++;
783
784 if( *aText == 'X' ) // Second parameter: size Y
785 {
786 aText++;
787 dcode->m_Size.y = KiROUND( ReadDouble( aText ) * conv_scale );
788 }
789
790 while( *aText == ' ' )
791 aText++;
792
793 if( *aText == 'X' ) // third parameter: drill size (or drill size X)
794 {
795 aText++;
796 dcode->m_Drill.x = KiROUND( ReadDouble( aText ) * conv_scale );
797 dcode->m_Drill.y = dcode->m_Drill.x;
799 }
800
801 while( *aText == ' ' )
802 aText++;
803
804 if( *aText == 'X' ) // fourth parameter: drill size Y
805 {
806 aText++;
807 dcode->m_Drill.y = KiROUND( ReadDouble( aText ) * conv_scale );
809 }
810
811 dcode->m_Defined = true;
812 break;
813
814 case 'P':
815
816 /* Regular polygon: a command line like %ADD12P,0.040X10X25X0.025X0.025X0.0150*%
817 * params are: <diameter>, X<edge count>, X<Rotation>, X<X hole dim>, X<Y hole dim>
818 */
819 dcode->m_ApertType = APT_POLYGON;
820
821 while( *aText == ' ' )
822 aText++;
823
824 if( *aText == 'X' )
825 {
826 aText++;
827 dcode->m_EdgesCount = ReadInt( aText );
828 }
829
830 while( *aText == ' ' )
831 aText++;
832
833 if( *aText == 'X' )
834 {
835 aText++;
836 dcode->m_Rotation = EDA_ANGLE( ReadDouble( aText ), DEGREES_T );
837 }
838
839 while( *aText == ' ' )
840 aText++;
841
842 if( *aText == 'X' )
843 {
844 aText++;
845 dcode->m_Drill.x = KiROUND( ReadDouble( aText ) * conv_scale );
846 dcode->m_Drill.y = dcode->m_Drill.x;
848 }
849
850 while( *aText == ' ' )
851 aText++;
852
853 if( *aText == 'X' )
854 {
855 aText++;
856 dcode->m_Drill.y = KiROUND( ReadDouble( aText ) * conv_scale );
858 }
859
860 dcode->m_Defined = true;
861 break;
862 }
863 }
864 else // aText[0] starts an aperture macro name
865 {
866 APERTURE_MACRO am_lookup;
867
868 while( *aText && *aText != '*' && *aText != ',' )
869 am_lookup.m_AmName.Append( *aText++ );
870
871 // When an aperture definition is like %AMLINE2* 22,1,$1,$2,0,0,-45*
872 // the ADDxx<MACRO_NAME> command has parameters, like %ADD14LINE2,0.8X0.5*%
873 if( *aText == ',' )
874 { // Read aperture macro parameters and store them
875 aText++; // aText points the first parameter
876
877 while( *aText && *aText != '*' )
878 {
879 double param = ReadDouble( aText );
880 dcode->AppendParam( param );
881
882 if( !( isspace( *aText ) || *aText == 'X' || *aText == 'x' || *aText == '*' ) )
883 {
884 msg.Printf( wxT( "RS274X: aperture macro %s has invalid template "
885 "parameters\n" ),
886 TO_UTF8( am_lookup.m_AmName ) );
887 AddMessageToList( msg );
888 ok = false;
889 break;
890 }
891
892 while( isspace( *aText ) )
893 aText++;
894
895 // Skip 'X' separator:
896 if( *aText == 'X' || *aText == 'x' )
897 aText++;
898 }
899 }
900
901 // lookup the aperture macro here.
902 APERTURE_MACRO* pam = FindApertureMacro( am_lookup );
903
904 if( !pam )
905 {
906 msg.Printf( wxT( "RS274X: aperture macro %s not found\n" ),
907 TO_UTF8( am_lookup.m_AmName ) );
908 AddMessageToList( msg );
909 ok = false;
910 break;
911 }
912
913 dcode->m_ApertType = APT_MACRO;
914 dcode->SetMacro( pam );
915 dcode->m_Defined = true;
916 }
917
918 break;
919
920 default:
921 ok = false;
922 break;
923 }
924
925 ignore_unused( seq_len );
926
927 if( !GetEndOfBlock( aBuff, aBuffSize, aText, m_Current_File ) )
928 ok = false;
929
930 return ok;
931}
932
933
934bool GERBER_FILE_IMAGE::GetEndOfBlock( char* aBuff, unsigned int aBuffSize, char*& aText, FILE* gerber_file )
935{
936 for( ; ; )
937 {
938 while( (aText < aBuff + aBuffSize) && *aText )
939 {
940 if( *aText == '*' )
941 return true;
942
943 if( *aText == '%' )
944 return true;
945
946 aText++;
947 }
948
949 if( fgets( aBuff, aBuffSize, gerber_file ) == nullptr )
950 break;
951
952 m_LineNum++;
953 aText = aBuff;
954 }
955
956 return false;
957}
958
959
960char* GERBER_FILE_IMAGE::GetNextLine( char *aBuff, unsigned int aBuffSize, char* aText, FILE* aFile )
961{
962 for( ; ; )
963 {
964 switch (*aText )
965 {
966 case ' ': // skip blanks
967 case '\n':
968 case '\r': // Skip line terminators
969 ++aText;
970 break;
971
972 case 0: // End of text found in aBuff: Read a new string
973 if( fgets( aBuff, aBuffSize, aFile ) == nullptr )
974 return nullptr;
975
976 m_LineNum++;
977 aText = aBuff;
978 return aText;
979
980 default:
981 return aText;
982 }
983 }
984}
985
986
987bool GERBER_FILE_IMAGE::ReadApertureMacro( char *aBuff, unsigned int aBuffSize, char*& aText,
988 FILE* gerber_file )
989{
990 wxString msg;
992
993 // read macro name
994 while( *aText )
995 {
996 if( *aText == '*' )
997 {
998 ++aText;
999 break;
1000 }
1001
1002 am.m_AmName.Append( *aText++ );
1003 }
1004
1005 // Read aperture macro parameters
1006 for( ; ; )
1007 {
1008 if( *aText == '*' )
1009 ++aText;
1010
1011 aText = GetNextLine( aBuff, aBuffSize, aText, gerber_file );
1012
1013 if( aText == nullptr ) // End of File
1014 return false;
1015
1016 // aText points the beginning of a new line.
1017
1018 // Test for the last line in aperture macro lis:
1019 // last line is % or *% sometime found.
1020 if( *aText == '*' )
1021 ++aText;
1022
1023 if( *aText == '%' )
1024 break; // exit with aText still pointing at %
1025
1026 int paramCount = 0; // will be set to the minimal parameters count,
1027 // depending on the actual primitive
1028 int primitive_type = AMP_UNKNOWN;
1029 // Test for a valid symbol at the beginning of a description:
1030 // it can be: a parameter declaration like $1=$2/4
1031 // or a digit (macro primitive selection)
1032 // all other symbols are illegal.
1033 if( *aText == '$' ) // local parameter declaration, inside the aperture macro
1034 {
1037 aText = GetNextLine( aBuff, aBuffSize, aText, gerber_file );
1038
1039 if( aText == nullptr) // End of File
1040 return false;
1041
1042 param.ReadParamFromAmDef( aText );
1043 continue;
1044 }
1045 else if( !isdigit(*aText) ) // Ill. symbol
1046 {
1047 msg.Printf( wxT( "RS274X: Aperture Macro \"%s\": ill. symbol, line: \"%s\"" ),
1048 am.m_AmName, From_UTF8( aBuff ) );
1049 AddMessageToList( msg );
1050 primitive_type = AMP_COMMENT;
1051 }
1052 else
1053 {
1054 primitive_type = ReadInt( aText );
1055 }
1056
1057 bool is_comment = false;
1058
1059 switch( primitive_type )
1060 {
1061 case AMP_COMMENT: // lines starting by 0 are a comment
1062 paramCount = 0;
1063 is_comment = true;
1064
1065 // Skip comment
1067
1068 break;
1069
1070 case AMP_CIRCLE:
1071 paramCount = 4; // minimal count. can have a optional parameter (rotation)
1072 break;
1073
1074 case AMP_LINE2:
1075 case AMP_LINE20:
1076 paramCount = 7;
1077 break;
1078
1079 case AMP_LINE_CENTER:
1081 paramCount = 6;
1082 break;
1083
1084 case AMP_OUTLINE:
1085 paramCount = 4; // partial count. other parameters are vertices and rotation
1086 // Second parameter is vertice (coordinate pairs) count.
1087 break;
1088
1089 case AMP_POLYGON:
1090 paramCount = 6;
1091 break;
1092
1093 case AMP_MOIRE:
1094 paramCount = 9;
1095 break;
1096
1097 case AMP_THERMAL:
1098 paramCount = 6;
1099 break;
1100
1101 default:
1102 msg.Printf( wxT( "RS274X: Aperture Macro \"%s\": Invalid primitive id code %d, line %d: \"%s\"" ),
1103 am.m_AmName, primitive_type, m_LineNum, From_UTF8( aBuff ) );
1104 AddMessageToList( msg );
1105 return false;
1106 }
1107
1108 if( is_comment )
1109 continue;
1110
1111 AM_PRIMITIVE prim( m_GerbMetric );
1112 prim.m_Primitive_id = (AM_PRIMITIVE_ID) primitive_type;
1113 int ii;
1114
1115 for( ii = 0; ii < paramCount && *aText && *aText != '*'; ++ii )
1116 {
1117 prim.m_Params.push_back( AM_PARAM() );
1118
1119 AM_PARAM& param = prim.m_Params.back();
1120
1121 aText = GetNextLine( aBuff, aBuffSize, aText, gerber_file );
1122
1123 if( aText == nullptr) // End of File
1124 return false;
1125
1126 param.ReadParamFromAmDef( aText );
1127 }
1128
1129 if( ii < paramCount )
1130 {
1131 // maybe some day we can throw an exception and track a line number
1132 msg.Printf( wxT( "RS274X: read macro descr type %d: read %d parameters, insufficient "
1133 "parameters\n" ),
1134 prim.m_Primitive_id, ii );
1135 AddMessageToList( msg );
1136 }
1137
1138 // there are more parameters to read if this is an AMP_OUTLINE
1139 if( prim.m_Primitive_id == AMP_OUTLINE )
1140 {
1141 // so far we have read [0]:exposure, [1]:#points, [2]:X start, [3]: Y start
1142 // Now read all the points, plus trailing rotation in degrees.
1143
1144 // m_Params[1] is a count of polygon points, so it must be given
1145 // in advance, i.e. be immediate.
1146 wxASSERT( prim.m_Params[1].IsImmediate() );
1147
1148 paramCount = (int) prim.m_Params[1].GetValueFromMacro( nullptr ) * 2 + 1;
1149
1150 for( int jj = 0; jj < paramCount && *aText != '*'; ++jj )
1151 {
1152 prim.m_Params.push_back( AM_PARAM() );
1153
1154 AM_PARAM& param = prim.m_Params.back();
1155
1156 aText = GetNextLine( aBuff, aBuffSize, aText, gerber_file );
1157
1158 if( aText == nullptr ) // End of File
1159 return false;
1160
1161 param.ReadParamFromAmDef( aText );
1162 }
1163 }
1164
1165 // AMP_CIRCLE can have a optional parameter (rotation)
1166 if( prim.m_Primitive_id == AMP_CIRCLE && aText && *aText != '*' )
1167 {
1168 prim.m_Params.push_back( AM_PARAM() );
1169 AM_PARAM& param = prim.m_Params.back();
1170 param.ReadParamFromAmDef( aText );
1171 }
1172
1173 // The primitive description is now parsed: push it to the current aperture macro
1174 am.AddPrimitiveToList( prim );
1175 }
1176
1177 m_aperture_macros.insert( std::move( am ) );
1178
1179 return true;
1180}
1181
int ReadInt(char *&text, bool aSkipSeparator=true)
Read an integer from an ASCII character buffer.
double ReadDouble(char *&text, bool aSkipSeparator=true)
Read a double precision floating point number from an ASCII character buffer.
AM_PRIMITIVE_ID
The set of all "aperture macro primitives" (primitive numbers).
Definition: am_primitive.h:69
@ AMP_POLYGON
Definition: am_primitive.h:79
@ AMP_LINE_LOWER_LEFT
Definition: am_primitive.h:77
@ AMP_LINE2
Definition: am_primitive.h:74
@ AMP_CIRCLE
Definition: am_primitive.h:73
@ AMP_THERMAL
Definition: am_primitive.h:82
@ AMP_UNKNOWN
Definition: am_primitive.h:70
@ AMP_COMMENT
Definition: am_primitive.h:71
@ AMP_LINE_CENTER
Definition: am_primitive.h:76
@ AMP_MOIRE
Definition: am_primitive.h:81
@ AMP_OUTLINE
Definition: am_primitive.h:78
@ AMP_LINE20
Definition: am_primitive.h:75
constexpr EDA_IU_SCALE gerbIUScale
Definition: base_units.h:111
constexpr BOX2I KiROUND(const BOX2D &aBoxD)
Definition: box2.h:990
Hold a parameter value for an "aperture macro" as defined within standard RS274X.
Definition: am_param.h:285
bool ReadParamFromAmDef(char *&aText)
Read one aperture macro parameter.
Definition: am_param.cpp:168
An aperture macro primitive as given in gerber layer format doc.
Definition: am_primitive.h:92
AM_PARAMS m_Params
A sequence of parameters used by the primitive.
Definition: am_primitive.h:95
AM_PRIMITIVE_ID m_Primitive_id
The primitive type.
Definition: am_primitive.h:94
Support the "aperture macro" defined within standard RS274X.
wxString m_AmName
The name of the aperture macro as defined like AMVB_RECTANGLE* (name is VB_RECTANGLE)
void AddLocalParamDefToStack()
A deferred parameter can be defined in aperture macro, but outside aperture primitives.
AM_PARAM & GetLastLocalParamDefFromStack()
void AddPrimitiveToList(AM_PRIMITIVE &aPrimitive)
Add a new ptimitive ( AMP_CIRCLE, AMP_LINE2 ...) to the list of primitives to define the full shape o...
A gerber DCODE (also called Aperture) definition.
Definition: dcode.h:80
wxString m_AperFunction
the aperture attribute (created by a TA.AperFunction command).
Definition: dcode.h:214
EDA_ANGLE m_Rotation
shape rotation
Definition: dcode.h:208
VECTOR2I m_Drill
dimension of the hole (if any) (drill file)
Definition: dcode.h:205
void SetMacro(APERTURE_MACRO *aMacro)
Definition: dcode.h:131
int m_EdgesCount
in aperture definition Polygon only: number of edges for the polygon
Definition: dcode.h:209
VECTOR2I m_Size
Horizontal and vertical dimensions.
Definition: dcode.h:201
APERTURE_T m_ApertType
Aperture type ( Line, rectangle, circle, oval poly, macro )
Definition: dcode.h:202
bool m_Defined
false if the aperture is not defined in the header
Definition: dcode.h:213
APERTURE_DEF_HOLETYPE m_DrillShape
shape of the hole (0 = no hole, round = 1, rect = 2).
Definition: dcode.h:206
void AppendParam(double aValue)
Add a parameter to the D_CODE parameter list.
Definition: dcode.h:102
void SetField(const wxString &aField, bool aUseUTF8, bool aEscapeString)
int m_NetAttribType
the type of net info (used to define the gerber string to create)
wxString m_Cmpref
the component reference parent of the data
@ GBR_NETINFO_NET
print info associated to a net (TO.N attribute)
@ GBR_NETINFO_CMP
print info associated to a component (TO.C attribute)
@ GBR_NETINFO_PAD
print info associated to a flashed pad (TO.P attribute)
GBR_DATA_FIELD m_PadPinFunction
for a pad: the pin function (defined in schematic)
GBR_DATA_FIELD m_Padname
for a flashed pad: the pad name ((TO.P attribute)
wxString m_Netname
for items associated to a net: the netname
APERTURE_MACRO * FindApertureMacro(const APERTURE_MACRO &aLookup)
Look up a previously read in aperture macro.
X2_ATTRIBUTE_FILEFUNCTION * m_FileFunction
file function parameters, found in a TF command or a G04
void RemoveAttribute(X2_ATTRIBUTE &aAttribute)
Called when a TD command is found the Gerber file.
static char m_LineBuffer[GERBER_BUFZ+1]
bool m_SwapAxis
false if A = X and B = Y (default); true if A = Y, B = X
double m_LocalRotation
Local rotation added to m_ImageRotation.
VECTOR2I m_Offset
Coord Offset, from OF command.
wxSize m_FmtScale
Fmt 2.3: m_FmtScale = 3, fmt 3.4: m_FmtScale = 4.
wxString m_FileName
Full File Name for this layer.
bool m_ImageJustifyXCenter
Image Justify Center on X axis (default = false)
bool m_ImageJustifyYCenter
Image Justify Center on Y axis (default = false)
bool m_ImageNegative
true = Negative image
void AddMessageToList(const wxString &aMessage)
Add a message to the message list.
int m_LineNum
Line number of the gerber file while reading.
wxString m_ImageName
Image name, from IN <name>* command.
bool m_Relative
false = absolute Coord, true = relative Coord.
wxString m_MD5_value
MD5 value found in a TF.MD5 command.
char * GetNextLine(char *aBuff, unsigned int aBuffSize, char *aText, FILE *aFile)
Test for an end of line.
Definition: rs274x.cpp:960
bool m_MirrorB
true: mirror / axis B (Y)
wxString m_PartString
string found in a TF.Part command
bool ReadRS274XCommand(char *aBuff, unsigned int aBuffSize, char *&aText)
Read a single RS274X command terminated with a %.
Definition: rs274x.cpp:142
bool m_IsX2_file
True if a X2 gerber attribute was found in file.
int m_ImageRotation
Image rotation (0, 90, 180, 270 only) in degrees.
VECTOR2I m_ImageOffset
Coord Offset, from IO command.
bool m_Has_DCode
< True if has DCodes in file or false if no DCodes found. Perhaps deprecated RS274D file.
bool GetEndOfBlock(char *aBuff, unsigned int aBuffSize, char *&aText, FILE *aGerberFile)
Definition: rs274x.cpp:934
bool ReadApertureMacro(char *aBuff, unsigned int aBuffSize, char *&text, FILE *gerber_file)
Read in an aperture macro and saves it in m_aperture_macros.
Definition: rs274x.cpp:987
D_CODE * GetDCODEOrCreate(int aDCODE, bool aCreateIfNoExist=true)
Return a pointer to the D_CODE within this GERBER for the given aDCODE.
bool ExecuteRS274XCommand(int aCommand, char *aBuff, unsigned int aBuffSize, char *&aText)
Execute a RS274X command.
Definition: rs274x.cpp:198
wxSize m_FmtLen
Nb chars per coord. ex fmt 2.3, m_FmtLen = 5.
APERTURE_MACRO_SET m_aperture_macros
int ReadXCommandID(char *&text)
Read two bytes of data and assembles them into an int with the first byte in the sequence put into th...
Definition: rs274x.cpp:114
bool m_GerbMetric
false = Inches, true = metric
GBR_NETLIST_METADATA m_NetAttributeDict
int m_CommandState
state of gerber analysis command
bool m_NoTrailingZeros
true: remove tailing zeros.
int m_Iterpolation
Linear, 90 arc, Circ.
bool m_MirrorA
true: mirror / axis A (X)
VECTOR2I m_Scale
scale (X and Y) of layer.
VECTOR2I m_ImageJustifyOffset
Image Justify Offset on XY axis (default = 0,0)
GERBER_LAYER & GetLayerParams()
wxRealPoint m_StepForRepeat
bool m_StepForRepeatMetric
X2_ATTRIBUTE_FILEFUNCTION ( from TF.FileFunction in Gerber file) Example file function: TF....
The attribute value consists of a number of substrings separated by a comma.
@ APT_DEF_ROUND_HOLE
Definition: dcode.h:62
@ APT_DEF_RECT_HOLE
Definition: dcode.h:63
@ APT_RECT
Definition: dcode.h:50
@ APT_OVAL
Definition: dcode.h:51
@ APT_POLYGON
Definition: dcode.h:52
@ APT_CIRCLE
Definition: dcode.h:49
@ APT_MACRO
Definition: dcode.h:54
#define SCALE_FACTOR(x)
#define _(s)
@ DEGREES_T
Definition: eda_angle.h:31
wxString FormatStringFromGerber(const wxString &aString)
Convert a gerber string into a 16 bit Unicode string.
Handle special data (items attributes) during plot.
#define GERBER_BUFZ
@ GERB_INTERPOL_LINEAR_1X
Definition: gerbview.h:35
@ CMD_IDLE
Definition: gerbview.h:64
void ignore_unused(const T &)
Definition: ignore.h:24
This file contains miscellaneous commonly used macros and functions.
#define KI_FALLTHROUGH
The KI_FALLTHROUGH macro is to be used when switch statement cases should purposely fallthrough from ...
Definition: macros.h:83
RS274X_PARAMETERS
Definition: rs274x.cpp:55
@ FILE_ATTRIBUTE
Definition: rs274x.cpp:85
@ IMAGE_JUSTIFY
Definition: rs274x.cpp:69
@ APERTURE_ATTRIBUTE
Definition: rs274x.cpp:93
@ FORMAT_STATEMENT
Definition: rs274x.cpp:59
@ NET_ATTRIBUTE
Definition: rs274x.cpp:90
@ IMAGE_OFFSET
Definition: rs274x.cpp:71
@ ROTATE
Definition: rs274x.cpp:107
@ STEP_AND_REPEAT
Definition: rs274x.cpp:106
@ LOAD_NAME
Definition: rs274x.cpp:110
@ REMOVE_APERTURE_ATTRIBUTE
Definition: rs274x.cpp:99
@ KNOCKOUT
Definition: rs274x.cpp:105
@ AP_MACRO
Definition: rs274x.cpp:78
@ MIRROR_IMAGE
Definition: rs274x.cpp:60
@ MODE_OF_UNITS
Definition: rs274x.cpp:61
@ INCH
Definition: rs274x.cpp:62
@ IMAGE_NAME
Definition: rs274x.cpp:70
@ OFFSET
Definition: rs274x.cpp:64
@ MILLIMETER
Definition: rs274x.cpp:63
@ AXIS_SELECT
Definition: rs274x.cpp:58
@ SCALE_FACTOR
Definition: rs274x.cpp:65
@ IMAGE_ROTATION
Definition: rs274x.cpp:73
@ LOAD_POLARITY
Definition: rs274x.cpp:109
@ IMAGE_POLARITY
Definition: rs274x.cpp:72
@ AP_DEFINITION
Definition: rs274x.cpp:77
#define CODE(x, y)
Definition: rs274x.cpp:42
int ReadInt(char *&text, bool aSkipSeparator=true)
Read an integer from an ASCII character buffer.
double ReadDouble(char *&text, bool aSkipSeparator=true)
Read a double precision floating point number from an ASCII character buffer.
std::vector< FAB_LAYER_COLOR > dummy
wxString From_UTF8(const char *cstring)
#define TO_UTF8(wxstring)
Convert a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: string_utils.h:429
const double IU_PER_MILS
Definition: base_units.h:77
VECTOR2< int32_t > VECTOR2I
Definition: vector2d.h:695