2011-09-23 13:57:12 +00:00
|
|
|
/**
|
|
|
|
* @file rs274x.cpp
|
|
|
|
*/
|
2007-06-05 12:10:51 +00:00
|
|
|
|
|
|
|
#include "fctsys.h"
|
|
|
|
#include "common.h"
|
2011-09-23 13:57:12 +00:00
|
|
|
#include "macros.h"
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2007-06-05 12:10:51 +00:00
|
|
|
#include "gerbview.h"
|
2010-10-06 17:28:07 +00:00
|
|
|
#include "class_GERBER.h"
|
2007-06-05 12:10:51 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
extern int ReadInt( char*& text, bool aSkipSeparator = true );
|
|
|
|
extern double ReadDouble( char*& text, bool aSkipSeparator = true );
|
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
#define CODE( x, y ) ( ( (x) << 8 ) + (y) )
|
2010-10-17 12:32:35 +00:00
|
|
|
|
2010-10-09 11:03:03 +00:00
|
|
|
// See rs274xrevd_e.pdf, table 1: RS-274X parameters order of entry
|
|
|
|
// in gerber files, when a coordinate is given (like X78Y600 or I0J80):
|
|
|
|
// Y and Y are logical coordinates
|
|
|
|
// A and B are plotter coordiantes
|
|
|
|
// Usually A = X, B = Y
|
|
|
|
// But we can have A = Y, B = X and/or offset, mirror, scale;
|
|
|
|
// Also:
|
|
|
|
// Image is what you must plot (the entire data of the file).
|
2011-09-23 13:57:12 +00:00
|
|
|
// Layer is just a set of data blocks with their parameters. An image can have more than one
|
2011-09-30 18:15:37 +00:00
|
|
|
// layer so a gerber layer is not like a board layer or the graphic layers used in GerbView
|
2011-09-23 13:57:12 +00:00
|
|
|
// to show a file.
|
2009-04-29 17:09:00 +00:00
|
|
|
enum RS274X_PARAMETERS {
|
2010-10-09 11:03:03 +00:00
|
|
|
// Directive parameters: single usage recommended
|
2010-10-09 20:05:03 +00:00
|
|
|
// Must be at the beginning of the file
|
2010-10-09 11:03:03 +00:00
|
|
|
AXIS_SELECT = CODE( 'A', 'S' ), // Default: A=X, B=Y
|
|
|
|
FORMAT_STATEMENT = CODE( 'F', 'S' ), // no default: this command must exists
|
|
|
|
MIRROR_IMAGE = CODE( 'M', 'I' ), // Default: mo mirror
|
|
|
|
MODE_OF_UNITS = CODE( 'M', 'O' ), // Default: inch
|
2009-04-29 17:09:00 +00:00
|
|
|
INCH = CODE( 'I', 'N' ),
|
|
|
|
MILLIMETER = CODE( 'M', 'M' ),
|
2010-10-09 11:03:03 +00:00
|
|
|
OFFSET = CODE( 'O', 'F' ), // Default: A = 0, B = 0
|
|
|
|
SCALE_FACTOR = CODE( 'S', 'F' ), // Default: A = 1.0, B = 1.0
|
|
|
|
|
|
|
|
// Image parameters:
|
|
|
|
// commands used only once at the beginning of the file
|
|
|
|
IMAGE_JUSTIFY = CODE( 'I', 'J' ), // Default: no justification
|
|
|
|
IMAGE_NAME = CODE( 'I', 'N' ), // Default: void
|
|
|
|
IMAGE_OFFSET = CODE( 'I', 'O' ), // Default: A = 0, B = 0
|
|
|
|
IMAGE_POLARITY = CODE( 'I', 'P' ), // Default: Positive
|
|
|
|
IMAGE_ROTATION = CODE( 'I', 'R' ), // Default: 0
|
|
|
|
PLOTTER_FILM = CODE( 'P', 'M' ),
|
|
|
|
|
|
|
|
// Aperture parameters:
|
|
|
|
// Usually for the whole file
|
2009-04-29 17:09:00 +00:00
|
|
|
AP_DEFINITION = CODE( 'A', 'D' ),
|
|
|
|
AP_MACRO = CODE( 'A', 'M' ),
|
2010-10-09 11:03:03 +00:00
|
|
|
|
|
|
|
// Layer specific parameters
|
|
|
|
// May be used singly or may be layer specfic
|
|
|
|
// theses parameters are at the beginning of the file or layer
|
2010-10-17 16:42:06 +00:00
|
|
|
// and reset some layer parameters (like interpolation)
|
2010-10-09 11:03:03 +00:00
|
|
|
LAYER_NAME = CODE( 'L', 'N' ), // Default: Positive
|
2009-04-29 17:09:00 +00:00
|
|
|
LAYER_POLARITY = CODE( 'L', 'P' ),
|
2010-10-09 11:03:03 +00:00
|
|
|
KNOCKOUT = CODE( 'K', 'O' ), // Default: off
|
2010-10-15 18:59:26 +00:00
|
|
|
STEP_AND_REPEAT = CODE( 'S', 'R' ), // Default: A = 1, B = 1
|
2010-10-09 11:03:03 +00:00
|
|
|
ROTATE = CODE( 'R', 'O' ), // Default: 0
|
|
|
|
|
|
|
|
// Miscellaneous parameters:
|
|
|
|
INCLUDE_FILE = CODE( 'I', 'F' )
|
2007-06-05 12:10:51 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-11-07 07:55:28 +00:00
|
|
|
/**
|
|
|
|
* Function ReadXCommand
|
2008-12-29 20:05:47 +00:00
|
|
|
* reads in two bytes of data and assembles them into an int with the first
|
2008-11-07 07:55:28 +00:00
|
|
|
* byte in the sequence put into the most significant part of a 16 bit value
|
|
|
|
* and the second byte put into the least significant part of the 16 bit value.
|
2009-04-29 17:09:00 +00:00
|
|
|
* @param text A reference to a pointer to read bytes from and to advance as
|
|
|
|
* they are read.
|
2008-11-07 07:55:28 +00:00
|
|
|
* @return int - with 16 bits of data in the ls bits, upper bits zeroed.
|
2007-09-25 15:10:01 +00:00
|
|
|
*/
|
|
|
|
static int ReadXCommand( char*& text )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2007-09-25 15:10:01 +00:00
|
|
|
int result;
|
|
|
|
|
|
|
|
if( text && *text )
|
2008-11-07 07:55:28 +00:00
|
|
|
result = *text++ << 8;
|
2007-09-25 15:10:01 +00:00
|
|
|
else
|
|
|
|
return -1;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
if( text && *text )
|
2008-11-07 07:55:28 +00:00
|
|
|
result += *text++;
|
2007-09-25 15:10:01 +00:00
|
|
|
else
|
|
|
|
return -1;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
return result;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-16 14:51:22 +00:00
|
|
|
bool GERBER_IMAGE::ReadRS274XCommand( char buff[GERBER_BUFZ], char*& text )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2007-09-25 15:10:01 +00:00
|
|
|
bool ok = true;
|
|
|
|
int code_command;
|
|
|
|
|
|
|
|
text++;
|
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
for( ; ; )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
while( *text )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
2008-11-08 06:44:07 +00:00
|
|
|
case '%': // end of command
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
m_CommandState = CMD_IDLE;
|
|
|
|
goto exit; // success completion
|
|
|
|
|
|
|
|
case ' ':
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '*':
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
code_command = ReadXCommand( text );
|
|
|
|
ok = ExecuteRS274XCommand( code_command, buff, text );
|
|
|
|
if( !ok )
|
|
|
|
goto exit;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
// end of current line, read another one.
|
2008-11-07 07:55:28 +00:00
|
|
|
if( fgets( buff, GERBER_BUFZ, m_Current_File ) == NULL )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2008-11-08 06:44:07 +00:00
|
|
|
// end of file
|
2007-09-25 15:10:01 +00:00
|
|
|
ok = false;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
text = buff;
|
|
|
|
}
|
|
|
|
|
|
|
|
exit:
|
|
|
|
return ok;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-16 14:51:22 +00:00
|
|
|
bool GERBER_IMAGE::ExecuteRS274XCommand( int command,
|
2010-10-09 11:03:03 +00:00
|
|
|
char buff[GERBER_BUFZ],
|
|
|
|
char*& text )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2007-09-25 15:10:01 +00:00
|
|
|
int code;
|
|
|
|
int xy_seq_len, xy_seq_char;
|
2010-12-02 17:26:32 +00:00
|
|
|
bool ok = true;
|
2008-11-07 07:55:28 +00:00
|
|
|
char line[GERBER_BUFZ];
|
2007-09-25 15:10:01 +00:00
|
|
|
wxString msg;
|
|
|
|
double fcoord;
|
2010-10-09 11:03:03 +00:00
|
|
|
double conv_scale = m_GerbMetric ? PCB_INTERNAL_UNIT / 25.4 : PCB_INTERNAL_UNIT;
|
2007-09-25 15:10:01 +00:00
|
|
|
|
2010-10-03 15:39:06 +00:00
|
|
|
// D( printf( "%22s: Command <%c%c>\n", __func__, (command >> 8) & 0xFF, command & 0xFF ); )
|
2008-12-16 02:20:21 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
switch( command )
|
|
|
|
{
|
2008-11-07 07:55:28 +00:00
|
|
|
case FORMAT_STATEMENT:
|
2007-09-25 15:10:01 +00:00
|
|
|
xy_seq_len = 2;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text != '*' )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case ' ':
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'L': // No Leading 0
|
2010-12-02 17:26:32 +00:00
|
|
|
m_DecimalFormat = false;
|
|
|
|
m_NoTrailingZeros = false;
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'T': // No trailing 0
|
2010-12-02 17:26:32 +00:00
|
|
|
m_DecimalFormat = false;
|
|
|
|
m_NoTrailingZeros = true;
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'D': // Decimal format: sometimes found, but not really documented
|
|
|
|
m_DecimalFormat = true;
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
2009-11-09 14:00:22 +00:00
|
|
|
case 'A': // Absolute coord
|
2010-12-02 17:26:32 +00:00
|
|
|
m_Relative = false;
|
2008-11-07 07:55:28 +00:00
|
|
|
text++;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2010-12-02 17:26:32 +00:00
|
|
|
case 'I': // Relative coord
|
|
|
|
m_Relative = true;
|
2008-11-07 07:55:28 +00:00
|
|
|
text++;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2009-11-09 14:00:22 +00:00
|
|
|
case 'N': // Sequence code (followed by the number of digits
|
|
|
|
// for the X,Y command
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
2008-11-07 07:55:28 +00:00
|
|
|
xy_seq_char = *text++;
|
2007-09-25 15:10:01 +00:00
|
|
|
if( (xy_seq_char >= '0') && (xy_seq_char <= '9') )
|
|
|
|
xy_seq_len = -'0';
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'X':
|
2009-11-09 14:00:22 +00:00
|
|
|
case 'Y': // Values transmitted :2 (really xy_seq_len : FIX
|
|
|
|
// ME) digits
|
2009-04-29 17:09:00 +00:00
|
|
|
{
|
|
|
|
code = *(text++);
|
|
|
|
char ctmp = *(text++) - '0';
|
|
|
|
if( code == 'X' )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2010-10-09 11:03:03 +00:00
|
|
|
// number of digits after the decimal point (0 to 6 allowed)
|
2009-11-09 14:00:22 +00:00
|
|
|
m_FmtScale.x = *text - '0';
|
|
|
|
m_FmtLen.x = ctmp + m_FmtScale.x;
|
2010-10-09 11:03:03 +00:00
|
|
|
|
|
|
|
// m_FmtScale is 0 to 6
|
2010-10-08 14:02:49 +00:00
|
|
|
if( m_FmtScale.x < 0 )
|
|
|
|
m_FmtScale.x = 0;
|
2010-10-09 11:03:03 +00:00
|
|
|
if( m_FmtScale.x > 6 )
|
|
|
|
m_FmtScale.x = 6;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2009-04-29 17:09:00 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
m_FmtScale.y = *text - '0';
|
|
|
|
m_FmtLen.y = ctmp + m_FmtScale.y;
|
2010-10-08 14:02:49 +00:00
|
|
|
if( m_FmtScale.y < 0 )
|
|
|
|
m_FmtScale.y = 0;
|
2010-10-09 11:03:03 +00:00
|
|
|
if( m_FmtScale.y > 6 )
|
|
|
|
m_FmtScale.y = 6;
|
2009-04-29 17:09:00 +00:00
|
|
|
}
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
break;
|
2007-09-25 15:10:01 +00:00
|
|
|
|
|
|
|
case '*':
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
GetEndOfBlock( buff, text, m_Current_File );
|
2010-12-02 17:26:32 +00:00
|
|
|
ok = false;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2010-10-16 14:51:22 +00:00
|
|
|
case AXIS_SELECT: // command ASAXBY*% or %ASAYBX*%
|
|
|
|
m_SwapAxis = false;
|
|
|
|
if( strnicmp( text, "AYBX", 4 ) == 0 )
|
|
|
|
m_SwapAxis = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MIRROR_IMAGE: // commanf %MIA0B0*%, %MIA0B1*%, %MIA1B0*%, %MIA1B1*%
|
|
|
|
m_MirrorA = m_MirrorB = 0;
|
|
|
|
while( *text && *text != '*' )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case 'A': // Mirror A axis ?
|
|
|
|
text++;
|
|
|
|
if( *text == '1' )
|
|
|
|
m_MirrorA = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'B': // Mirror B axis ?
|
|
|
|
text++;
|
|
|
|
if( *text == '1' )
|
|
|
|
m_MirrorB = true;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case MODE_OF_UNITS:
|
|
|
|
code = ReadXCommand( text );
|
|
|
|
if( code == INCH )
|
2010-12-02 17:26:32 +00:00
|
|
|
m_GerbMetric = false;
|
2007-09-25 15:10:01 +00:00
|
|
|
else if( code == MILLIMETER )
|
2010-12-02 17:26:32 +00:00
|
|
|
m_GerbMetric = true;
|
2010-10-09 11:03:03 +00:00
|
|
|
conv_scale = m_GerbMetric ? PCB_INTERNAL_UNIT / 25.4 : PCB_INTERNAL_UNIT;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2010-10-09 20:05:03 +00:00
|
|
|
case OFFSET: // command: OFAnnBnn (nn = float number) = layer Offset
|
2007-09-25 15:10:01 +00:00
|
|
|
m_Offset.x = m_Offset.y = 0;
|
|
|
|
while( *text != '*' )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
2009-11-09 14:00:22 +00:00
|
|
|
case 'A': // A axis offset in current unit (inch or mm)
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
fcoord = ReadDouble( text );
|
2009-04-05 20:49:15 +00:00
|
|
|
m_Offset.x = wxRound( fcoord * conv_scale );
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2009-11-09 14:00:22 +00:00
|
|
|
case 'B': // B axis offset in current unit (inch or mm)
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
fcoord = ReadDouble( text );
|
2009-04-05 20:49:15 +00:00
|
|
|
m_Offset.y = wxRound( fcoord * conv_scale );
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SCALE_FACTOR:
|
2010-10-16 14:51:22 +00:00
|
|
|
m_Scale.x = m_Scale.y = 1.0;
|
2010-10-08 14:02:49 +00:00
|
|
|
while( *text != '*' )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case 'A': // A axis scale
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
m_Scale.x = ReadDouble( text );
|
2010-10-08 14:02:49 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'B': // B axis scale
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
m_Scale.y = ReadDouble( text );
|
2010-10-08 14:02:49 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-10-09 20:05:03 +00:00
|
|
|
break;
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2010-10-09 20:05:03 +00:00
|
|
|
case IMAGE_OFFSET: // command: IOAnnBnn (nn = float number) = Image Offset
|
|
|
|
m_ImageOffset.x = m_ImageOffset.y = 0;
|
|
|
|
while( *text != '*' )
|
2010-10-08 14:02:49 +00:00
|
|
|
{
|
2010-10-09 20:05:03 +00:00
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case 'A': // A axis offset in current unit (inch or mm)
|
|
|
|
text++;
|
|
|
|
fcoord = ReadDouble( text );
|
|
|
|
m_ImageOffset.x = wxRound( fcoord * conv_scale );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'B': // B axis offset in current unit (inch or mm)
|
|
|
|
text++;
|
|
|
|
fcoord = ReadDouble( text );
|
|
|
|
m_ImageOffset.y = wxRound( fcoord * conv_scale );
|
|
|
|
break;
|
|
|
|
}
|
2010-10-08 14:02:49 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-10-09 20:05:03 +00:00
|
|
|
case IMAGE_ROTATION: // command IR0* or IR90* or IR180* or IR270*
|
|
|
|
if( strnicmp( text, "0*", 2 ) == 0 )
|
2010-10-16 14:51:22 +00:00
|
|
|
m_ImageRotation = 0;
|
2010-10-09 20:05:03 +00:00
|
|
|
if( strnicmp( text, "90*", 2 ) == 0 )
|
2010-10-17 16:42:06 +00:00
|
|
|
m_ImageRotation = 90;
|
2010-10-09 20:05:03 +00:00
|
|
|
if( strnicmp( text, "180*", 2 ) == 0 )
|
2010-10-17 16:42:06 +00:00
|
|
|
m_ImageRotation = 180;
|
2010-10-09 20:05:03 +00:00
|
|
|
if( strnicmp( text, "270*", 2 ) == 0 )
|
2010-10-17 16:42:06 +00:00
|
|
|
m_ImageRotation = 270;
|
2010-10-09 20:05:03 +00:00
|
|
|
else
|
|
|
|
ReportMessage( _( "RS274X: Command \"IR\" rotation value not allowed" ) );
|
|
|
|
break;
|
|
|
|
|
2010-10-15 18:59:26 +00:00
|
|
|
case STEP_AND_REPEAT: // command SR, like %SRX3Y2I5.0J2*%
|
2010-10-17 16:42:06 +00:00
|
|
|
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_StepForRepeat.x = 0.0;
|
|
|
|
GetLayerParams().m_StepForRepeat.x = 0.0; // offset for Step and Repeat command
|
|
|
|
GetLayerParams().m_XRepeatCount = 1;
|
|
|
|
GetLayerParams().m_YRepeatCount = 1; // The repeat count
|
|
|
|
GetLayerParams().m_StepForRepeatMetric = m_GerbMetric; // the step units
|
2010-10-15 18:59:26 +00:00
|
|
|
while( *text && *text != '*' )
|
|
|
|
{
|
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case 'I': // X axis offset
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_StepForRepeat.x = ReadDouble( text );
|
2010-10-15 18:59:26 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'J': // Y axis offset
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_StepForRepeat.y = ReadDouble( text );
|
2010-10-15 18:59:26 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'X': // X axis repeat count
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_XRepeatCount = ReadInt( text );
|
2010-10-15 18:59:26 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case 'Y': // Y axis offset
|
|
|
|
text++;
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_YRepeatCount = ReadInt( text );
|
2010-10-15 18:59:26 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
case IMAGE_JUSTIFY: // Command IJAnBn*
|
|
|
|
m_ImageJustifyXCenter = false; // Image Justify Center on X axis (default = false)
|
|
|
|
m_ImageJustifyYCenter = false; // Image Justify Center on Y axis (default = false)
|
|
|
|
m_ImageJustifyOffset = wxPoint(0,0); // Image Justify Offset on XY axis (default = 0,0)
|
|
|
|
while( *text && *text != '*' )
|
|
|
|
{
|
|
|
|
// IJ command is (for A or B axis) AC or AL or A<coordinate>
|
|
|
|
switch( *text )
|
|
|
|
{
|
|
|
|
case 'A': // A axis justify
|
|
|
|
text++;
|
|
|
|
if( *text == 'C' )
|
|
|
|
{
|
|
|
|
m_ImageJustifyXCenter = true;
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
else if( *text == 'L' )
|
|
|
|
{
|
|
|
|
m_ImageJustifyXCenter = true;
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
else m_ImageJustifyOffset.x = wxRound( ReadDouble( text ) * conv_scale);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'B': // B axis justify
|
|
|
|
text++;
|
|
|
|
if( *text == 'C' )
|
|
|
|
{
|
|
|
|
m_ImageJustifyYCenter = true;
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
else if( *text == 'L' )
|
|
|
|
{
|
|
|
|
m_ImageJustifyYCenter = true;
|
|
|
|
text++;
|
|
|
|
}
|
|
|
|
else m_ImageJustifyOffset.y = wxRound( ReadDouble( text ) * conv_scale);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( m_ImageJustifyXCenter )
|
|
|
|
m_ImageJustifyOffset.x = 0;
|
|
|
|
if( m_ImageJustifyYCenter )
|
|
|
|
m_ImageJustifyOffset.y = 0;
|
|
|
|
break;
|
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
case KNOCKOUT:
|
2010-10-17 16:42:06 +00:00
|
|
|
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
|
2011-09-30 18:15:37 +00:00
|
|
|
msg = _( "RS274X: Command KNOCKOUT ignored by GerbView" ) ;
|
2010-10-17 12:32:35 +00:00
|
|
|
ReportMessage( msg );
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PLOTTER_FILM: // Command PF <string>
|
|
|
|
// This is an info about film that must be used to plot this file
|
|
|
|
// Has no meaning here. We just display this string
|
2010-10-18 12:34:45 +00:00
|
|
|
msg = wxT( "Plotter Film info:<br>" );
|
2010-10-17 12:32:35 +00:00
|
|
|
while( *text != '*' )
|
|
|
|
{
|
|
|
|
msg.Append( *text++ );
|
|
|
|
}
|
2010-10-05 11:44:34 +00:00
|
|
|
ReportMessage( msg );
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2010-10-16 14:51:22 +00:00
|
|
|
case ROTATE: // Layer rotation: command like %RO45*%
|
2010-10-17 16:42:06 +00:00
|
|
|
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
|
|
|
|
m_LocalRotation =ReadDouble( text ); // Store layer rotation in degrees
|
2010-10-16 14:51:22 +00:00
|
|
|
break;
|
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
case IMAGE_NAME:
|
2010-10-06 17:28:07 +00:00
|
|
|
m_ImageName.Empty();
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text != '*' )
|
|
|
|
{
|
2010-10-06 17:28:07 +00:00
|
|
|
m_ImageName.Append( *text++ );
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2010-10-06 17:28:07 +00:00
|
|
|
break;
|
2007-09-25 15:10:01 +00:00
|
|
|
|
2010-10-06 17:28:07 +00:00
|
|
|
case LAYER_NAME:
|
2010-10-17 16:42:06 +00:00
|
|
|
m_Iterpolation = GERB_INTERPOL_LINEAR_1X; // Start a new Gerber layer
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams( ).m_LayerName.Empty();
|
2010-10-06 17:28:07 +00:00
|
|
|
while( *text != '*' )
|
|
|
|
{
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams( ).m_LayerName.Append( *text++ );
|
2010-10-06 17:28:07 +00:00
|
|
|
}
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case IMAGE_POLARITY:
|
|
|
|
if( strnicmp( text, "NEG", 3 ) == 0 )
|
2008-12-29 20:05:47 +00:00
|
|
|
m_ImageNegative = true;
|
2007-09-25 15:10:01 +00:00
|
|
|
else
|
2008-12-29 20:05:47 +00:00
|
|
|
m_ImageNegative = false;
|
2009-04-29 17:09:00 +00:00
|
|
|
D( printf( "%22s: IMAGE_POLARITY m_ImageNegative=%s\n", __func__,
|
|
|
|
m_ImageNegative ? "true" : "false" ); )
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LAYER_POLARITY:
|
|
|
|
if( *text == 'C' )
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_LayerNegative = true;
|
2010-12-15 20:15:24 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
else
|
2010-10-16 14:51:22 +00:00
|
|
|
GetLayerParams().m_LayerNegative = false;
|
2009-04-29 17:09:00 +00:00
|
|
|
D( printf( "%22s: LAYER_POLARITY m_LayerNegative=%s\n", __func__,
|
2010-10-18 10:49:09 +00:00
|
|
|
GetLayerParams().m_LayerNegative ? "true" : "false" ); )
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case INCLUDE_FILE:
|
2010-10-09 11:03:03 +00:00
|
|
|
if( m_FilesPtr >= INCLUDE_FILES_CNT_MAX )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2010-12-02 17:26:32 +00:00
|
|
|
ok = false;
|
2010-10-06 17:28:07 +00:00
|
|
|
ReportMessage( _( "Too many include files!!" ) );
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
strcpy( line, text );
|
|
|
|
strtok( line, "*%%\n\r" );
|
2007-09-25 15:10:01 +00:00
|
|
|
m_FilesList[m_FilesPtr] = m_Current_File;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
|
|
|
m_Current_File = fopen( line, "rt" );
|
2007-09-25 15:10:01 +00:00
|
|
|
if( m_Current_File == 0 )
|
|
|
|
{
|
2010-10-06 17:28:07 +00:00
|
|
|
msg.Printf( wxT( "include file <%s> not found." ), line );
|
|
|
|
ReportMessage( msg );
|
2010-12-02 17:26:32 +00:00
|
|
|
ok = false;
|
2007-09-25 15:10:01 +00:00
|
|
|
m_Current_File = m_FilesList[m_FilesPtr];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
m_FilesPtr++;
|
|
|
|
break;
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
case AP_MACRO: // lines like %AMMYMACRO*
|
|
|
|
// 5,1,8,0,0,1.08239X$1,22.5*
|
|
|
|
// %
|
2008-11-09 02:57:42 +00:00
|
|
|
ok = ReadApertureMacro( buff, text, m_Current_File );
|
|
|
|
break;
|
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AP_DEFINITION:
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2010-09-28 19:34:16 +00:00
|
|
|
/* input example: %ADD30R,0.081800X0.101500*%
|
|
|
|
* Aperture definition has 4 options: C, R, O, P
|
|
|
|
* (Circle, Rect, Oval, regular Polygon)
|
|
|
|
* and shapes can have a hole (round or rectangular).
|
|
|
|
* All optional parameters values start by X
|
|
|
|
* at this point, text points to 2nd 'D'
|
|
|
|
*/
|
2008-11-09 02:57:42 +00:00
|
|
|
if( *text++ != 'D' )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2010-12-02 17:26:32 +00:00
|
|
|
ok = false;
|
2008-11-07 07:55:28 +00:00
|
|
|
break;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2008-11-09 02:57:42 +00:00
|
|
|
|
2010-12-02 17:26:32 +00:00
|
|
|
m_Has_DCode = true;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
code = ReadInt( text );
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
D_CODE* dcode;
|
2008-11-09 02:57:42 +00:00
|
|
|
dcode = GetDCODE( code );
|
2007-09-25 15:10:01 +00:00
|
|
|
if( dcode == NULL )
|
|
|
|
break;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
// at this point, text points to character after the ADD<num>,
|
|
|
|
// i.e. R in example above. If text[0] is one of the usual
|
|
|
|
// apertures: (C,R,O,P), there is a comma after it.
|
2008-11-09 02:57:42 +00:00
|
|
|
if( text[1] == ',' )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2009-04-29 17:09:00 +00:00
|
|
|
char stdAperture = *text;
|
2008-11-09 02:57:42 +00:00
|
|
|
|
|
|
|
text += 2; // skip "C," for example
|
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
dcode->m_Size.x = dcode->m_Size.y =
|
2010-10-09 11:03:03 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2007-09-25 15:10:01 +00:00
|
|
|
|
2010-09-28 19:34:16 +00:00
|
|
|
switch( stdAperture ) // Aperture desceiption has optional parameters. Read them
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
case 'C': // Circle
|
2008-11-08 06:44:07 +00:00
|
|
|
dcode->m_Shape = APT_CIRCLE;
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.x = dcode->m_Drill.y =
|
2010-10-09 11:03:03 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2010-09-28 19:34:16 +00:00
|
|
|
dcode->m_DrillShape = APT_DEF_ROUND_HOLE;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.y =
|
2009-04-05 20:49:15 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2010-09-28 19:34:16 +00:00
|
|
|
dcode->m_DrillShape = APT_DEF_RECT_HOLE;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2010-12-02 17:26:32 +00:00
|
|
|
dcode->m_Defined = true;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case 'O': // oval
|
2007-09-25 15:10:01 +00:00
|
|
|
case 'R': // rect
|
2008-11-09 02:57:42 +00:00
|
|
|
dcode->m_Shape = (stdAperture == 'O') ? APT_OVAL : APT_RECT;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Size.y =
|
2009-04-05 20:49:15 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.x = dcode->m_Drill.y =
|
2010-10-09 11:03:03 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2010-09-28 19:34:16 +00:00
|
|
|
dcode->m_DrillShape = APT_DEF_ROUND_HOLE;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
2010-09-28 14:42:05 +00:00
|
|
|
if( *text == 'X' )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.y =
|
2009-04-05 20:49:15 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2010-09-28 19:34:16 +00:00
|
|
|
dcode->m_DrillShape = APT_DEF_RECT_HOLE;
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
2010-12-02 17:26:32 +00:00
|
|
|
dcode->m_Defined = true;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
2010-09-28 19:34:16 +00:00
|
|
|
case 'P':
|
2010-10-09 11:03:03 +00:00
|
|
|
|
2010-09-28 19:34:16 +00:00
|
|
|
/* Regular polygon: a command line like %ADD12P,0.040X10X25X0.025X0.025X0.0150*%
|
|
|
|
* params are: <diameter>, X<edge count>, X<Rotation>, X<X hole dim>, X<Y hole dim>
|
|
|
|
*/
|
|
|
|
dcode->m_Shape = APT_POLYGON;
|
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_EdgesCount = ReadInt( text );
|
|
|
|
}
|
|
|
|
|
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Rotation = ReadDouble( text );
|
|
|
|
}
|
|
|
|
|
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.x = dcode->m_Drill.y =
|
2010-10-09 11:03:03 +00:00
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
2010-09-28 19:34:16 +00:00
|
|
|
dcode->m_DrillShape = APT_DEF_ROUND_HOLE;
|
|
|
|
}
|
|
|
|
|
|
|
|
while( *text == ' ' )
|
|
|
|
text++;
|
|
|
|
|
|
|
|
if( *text == 'X' )
|
|
|
|
{
|
|
|
|
text++;
|
|
|
|
dcode->m_Drill.y =
|
|
|
|
wxRound( ReadDouble( text ) * conv_scale );
|
|
|
|
dcode->m_DrillShape = APT_DEF_RECT_HOLE;
|
|
|
|
}
|
2010-12-02 17:26:32 +00:00
|
|
|
dcode->m_Defined = true;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-11-09 02:57:42 +00:00
|
|
|
else // text[0] starts an aperture macro name
|
|
|
|
{
|
2009-04-29 17:09:00 +00:00
|
|
|
APERTURE_MACRO am_lookup;
|
2008-11-09 02:57:42 +00:00
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
while( *text && *text != '*' && *text != ',' )
|
2008-11-09 02:57:42 +00:00
|
|
|
am_lookup.name.Append( *text++ );
|
|
|
|
|
2010-10-09 11:03:03 +00:00
|
|
|
// When an aperture definition is like %AMLINE2* 22,1,$1,$2,0,0,-45*
|
|
|
|
// the ADDxx<MACRO_NAME> command has parameters, like %ADD14LINE2,0.8X0.5*%
|
|
|
|
if( *text == ',' )
|
|
|
|
{ // Read aperture macro parameters and store them
|
|
|
|
text++; // text points the first parameter
|
2009-04-29 17:09:00 +00:00
|
|
|
while( *text && *text != '*' )
|
2008-11-09 02:57:42 +00:00
|
|
|
{
|
|
|
|
double param = ReadDouble( text );
|
|
|
|
dcode->AppendParam( param );
|
2010-10-09 11:03:03 +00:00
|
|
|
while( isspace( *text ) ) text++;
|
|
|
|
if( *text == 'X' )
|
|
|
|
++text;
|
2008-11-09 02:57:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// lookup the aperture macro here.
|
|
|
|
APERTURE_MACRO* pam = FindApertureMacro( am_lookup );
|
|
|
|
if( !pam )
|
|
|
|
{
|
2010-10-05 19:54:27 +00:00
|
|
|
msg.Printf( wxT( "RS274X: aperture macro %s not found\n" ),
|
2011-02-28 18:36:19 +00:00
|
|
|
TO_UTF8( am_lookup.name ) );
|
2010-10-05 11:44:34 +00:00
|
|
|
ReportMessage( msg );
|
2008-11-09 02:57:42 +00:00
|
|
|
ok = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-11-14 07:46:43 +00:00
|
|
|
dcode->m_Shape = APT_MACRO;
|
2008-11-09 02:57:42 +00:00
|
|
|
dcode->SetMacro( (APERTURE_MACRO*) pam );
|
|
|
|
}
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2010-12-02 17:26:32 +00:00
|
|
|
ok = false;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
ok = GetEndOfBlock( buff, text, m_Current_File );
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
return ok;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
|
2008-11-07 07:55:28 +00:00
|
|
|
bool GetEndOfBlock( char buff[GERBER_BUFZ], char*& text, FILE* gerber_file )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2009-04-29 17:09:00 +00:00
|
|
|
for( ; ; )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
2008-11-07 07:55:28 +00:00
|
|
|
while( (text < buff + GERBER_BUFZ) && *text )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
if( *text == '*' )
|
2010-12-02 17:26:32 +00:00
|
|
|
return true;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
if( *text == '%' )
|
2010-12-02 17:26:32 +00:00
|
|
|
return true;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
text++;
|
|
|
|
}
|
|
|
|
|
2008-11-07 07:55:28 +00:00
|
|
|
if( fgets( buff, GERBER_BUFZ, gerber_file ) == NULL )
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2007-09-25 15:10:01 +00:00
|
|
|
text = buff;
|
|
|
|
}
|
|
|
|
|
2010-12-02 17:26:32 +00:00
|
|
|
return false;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
|
|
|
|
2010-11-12 16:36:43 +00:00
|
|
|
/**
|
|
|
|
* Function GetNextLine
|
2010-10-17 12:32:35 +00:00
|
|
|
* test for an end of line
|
|
|
|
* if an end of line is found:
|
|
|
|
* read a new line
|
2010-12-18 18:47:58 +00:00
|
|
|
* @param aBuff = buffer (size = GERBER_BUFZ) to fill with a new line
|
2010-10-17 12:32:35 +00:00
|
|
|
* @param aText = pointer to the last useful char in aBuff
|
|
|
|
* on return: points the beginning of the next line.
|
|
|
|
* @param aFile = the opened GERBER file to read
|
|
|
|
* @return a pointer to the beginning of the next line or NULL if end of file
|
|
|
|
*/
|
|
|
|
static char* GetNextLine( char aBuff[GERBER_BUFZ], char* aText, FILE* aFile )
|
2010-05-11 16:35:40 +00:00
|
|
|
{
|
2010-10-17 12:32:35 +00:00
|
|
|
for( ; ; )
|
2010-05-11 16:35:40 +00:00
|
|
|
{
|
2010-10-17 12:32:35 +00:00
|
|
|
switch (*aText )
|
2010-05-11 16:35:40 +00:00
|
|
|
{
|
2010-10-17 12:32:35 +00:00
|
|
|
case ' ': // skip blanks
|
|
|
|
case '\n':
|
|
|
|
case '\r': // Skip line terminators
|
|
|
|
++aText;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 0: // End of text found in aBuff: Read a new string
|
|
|
|
if( fgets( aBuff, GERBER_BUFZ, aFile ) == NULL )
|
|
|
|
return NULL;
|
|
|
|
aText = aBuff;
|
|
|
|
return aText;
|
2010-05-11 16:35:40 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
default:
|
|
|
|
return aText;
|
2010-05-11 16:35:40 +00:00
|
|
|
}
|
|
|
|
}
|
2010-10-17 12:32:35 +00:00
|
|
|
return aText;
|
2010-05-11 16:35:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-16 14:51:22 +00:00
|
|
|
bool GERBER_IMAGE::ReadApertureMacro( char buff[GERBER_BUFZ],
|
2010-10-09 11:03:03 +00:00
|
|
|
char*& text,
|
|
|
|
FILE* gerber_file )
|
2007-06-05 12:10:51 +00:00
|
|
|
{
|
2010-10-09 11:03:03 +00:00
|
|
|
wxString msg;
|
2008-11-14 18:26:56 +00:00
|
|
|
APERTURE_MACRO am;
|
2007-09-25 15:10:01 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
// read macro name
|
|
|
|
while( *text )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
if( *text == '*' )
|
2008-11-08 06:44:07 +00:00
|
|
|
{
|
|
|
|
++text;
|
2007-09-25 15:10:01 +00:00
|
|
|
break;
|
2008-11-08 06:44:07 +00:00
|
|
|
}
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
am.name.Append( *text++ );
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
// Read aperture macro parameters
|
2009-04-29 17:09:00 +00:00
|
|
|
for( ; ; )
|
2007-09-25 15:10:01 +00:00
|
|
|
{
|
|
|
|
if( *text == '*' )
|
2008-11-08 06:44:07 +00:00
|
|
|
++text;
|
2008-11-07 07:55:28 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
text = GetNextLine( buff, text, gerber_file ); // Get next line
|
|
|
|
if( text == NULL ) // End of File
|
2010-05-11 16:35:40 +00:00
|
|
|
return false;
|
2008-11-08 06:44:07 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
// text points the beginning of a new line.
|
|
|
|
|
|
|
|
// Test for the last line in aperture macro lis:
|
|
|
|
// last line is % or *% sometime found.
|
|
|
|
if( *text == '*' )
|
|
|
|
++text;
|
2008-11-08 06:44:07 +00:00
|
|
|
if( *text == '%' )
|
|
|
|
break; // exit with text still pointing at %
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
int paramCount = 0;
|
2010-10-25 09:57:00 +00:00
|
|
|
int primitive_type = AMP_UNKNOWN;
|
|
|
|
// Test for a valid symbol at the beginning of a description:
|
|
|
|
// it can be: a parameter declaration like $1=$2/4
|
|
|
|
// or a digit (macro primitive selection)
|
|
|
|
// all other symbols are illegal.
|
2010-12-01 19:30:52 +00:00
|
|
|
if( *text == '$' ) // local parameter declaration, inside the aperture macro
|
2010-10-25 09:57:00 +00:00
|
|
|
{
|
2010-12-01 19:30:52 +00:00
|
|
|
am.m_localparamStack.push_back( AM_PARAM() );
|
|
|
|
AM_PARAM& param = am.m_localparamStack.back();
|
|
|
|
text = GetNextLine( buff, text, gerber_file );
|
|
|
|
if( text == NULL) // End of File
|
|
|
|
return false;
|
|
|
|
param.ReadParam( text );
|
|
|
|
continue;
|
2010-10-25 09:57:00 +00:00
|
|
|
}
|
|
|
|
else if( !isdigit(*text) ) // Ill. symbol
|
|
|
|
{
|
|
|
|
msg.Printf( wxT( "RS274X: Aperture Macro \"%s\": ill. symbol, line: \"%s\"" ),
|
2011-02-28 18:36:19 +00:00
|
|
|
GetChars( am.name ), GetChars( FROM_UTF8( buff ) ) );
|
2010-10-25 09:57:00 +00:00
|
|
|
ReportMessage( msg );
|
|
|
|
primitive_type = AMP_COMMENT;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
primitive_type = ReadInt( text );
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
switch( primitive_type )
|
2008-11-08 06:44:07 +00:00
|
|
|
{
|
2010-10-25 10:22:54 +00:00
|
|
|
case AMP_COMMENT: // lines starting by 0 are a comment
|
|
|
|
paramCount = 0;
|
2010-10-25 09:57:00 +00:00
|
|
|
// Skip comment
|
|
|
|
while( *text && (*text != '*') )
|
|
|
|
text++;
|
|
|
|
break;
|
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_CIRCLE:
|
|
|
|
paramCount = 4;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_LINE2:
|
|
|
|
case AMP_LINE20:
|
|
|
|
paramCount = 7;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_LINE_CENTER:
|
|
|
|
case AMP_LINE_LOWER_LEFT:
|
|
|
|
paramCount = 6;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_EOF:
|
|
|
|
paramCount = 0;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_OUTLINE:
|
|
|
|
paramCount = 4;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_POLYGON:
|
2010-10-03 15:39:06 +00:00
|
|
|
paramCount = 6;
|
2008-11-08 06:44:07 +00:00
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_MOIRE:
|
|
|
|
paramCount = 9;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
case AMP_THERMAL:
|
|
|
|
paramCount = 6;
|
|
|
|
break;
|
2009-04-29 17:09:00 +00:00
|
|
|
|
2008-11-09 02:57:42 +00:00
|
|
|
default:
|
2009-04-29 17:09:00 +00:00
|
|
|
// @todo, there needs to be a way of reporting the line number
|
2010-10-17 12:32:35 +00:00
|
|
|
msg.Printf( wxT( "RS274X: Aperture Macro \"%s\": Invalid primitive id code %d, line: \"%s\"" ),
|
2011-02-28 18:36:19 +00:00
|
|
|
GetChars( am.name ), primitive_type, GetChars( FROM_UTF8( buff ) ) );
|
2010-10-05 11:44:34 +00:00
|
|
|
ReportMessage( msg );
|
2008-11-09 02:57:42 +00:00
|
|
|
return false;
|
2008-11-08 06:44:07 +00:00
|
|
|
}
|
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
AM_PRIMITIVE prim( m_GerbMetric );
|
|
|
|
prim.primitive_id = (AM_PRIMITIVE_ID) primitive_type;
|
2008-12-16 02:20:21 +00:00
|
|
|
int i;
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
for( i = 0; i < paramCount && *text && *text != '*'; ++i )
|
2008-11-08 06:44:07 +00:00
|
|
|
{
|
2010-11-30 20:41:35 +00:00
|
|
|
prim.params.push_back( AM_PARAM() );
|
2008-11-14 18:26:56 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
AM_PARAM& param = prim.params.back();
|
2008-11-09 02:57:42 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
text = GetNextLine( buff, text, gerber_file );
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
if( text == NULL) // End of File
|
2010-05-11 16:35:40 +00:00
|
|
|
return false;
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
param.ReadParam( text );
|
2008-11-08 06:44:07 +00:00
|
|
|
}
|
|
|
|
|
2010-10-05 11:44:34 +00:00
|
|
|
if( i < paramCount )
|
2010-10-09 11:03:03 +00:00
|
|
|
{
|
|
|
|
// maybe some day we can throw an exception and track a line number
|
2010-10-18 12:34:45 +00:00
|
|
|
msg.Printf( wxT( "RS274X: read macro descr type %d: read %d parameters, insufficient parameters\n" ),
|
2010-10-05 13:46:53 +00:00
|
|
|
prim.primitive_id, i );
|
2010-10-05 11:44:34 +00:00
|
|
|
ReportMessage( msg );
|
2010-10-17 12:32:35 +00:00
|
|
|
|
2010-10-05 11:44:34 +00:00
|
|
|
}
|
2008-11-09 02:57:42 +00:00
|
|
|
// there are more parameters to read if this is an AMP_OUTLINE
|
2008-11-08 06:44:07 +00:00
|
|
|
if( prim.primitive_id == AMP_OUTLINE )
|
|
|
|
{
|
2010-05-11 16:35:40 +00:00
|
|
|
// so far we have read [0]:exposure, [1]:#points, [2]:X start, [3]: Y start
|
|
|
|
// Now read all the points, plus trailing rotation in degrees.
|
|
|
|
|
2008-11-09 02:57:42 +00:00
|
|
|
// params[1] is a count of polygon points, so it must be given
|
|
|
|
// in advance, i.e. be immediate.
|
|
|
|
wxASSERT( prim.params[1].IsImmediate() );
|
|
|
|
|
2009-04-29 17:09:00 +00:00
|
|
|
paramCount = (int) prim.params[1].GetValue( 0 ) * 2 + 1;
|
2008-11-08 06:44:07 +00:00
|
|
|
|
2010-05-11 16:35:40 +00:00
|
|
|
for( int i = 0; i < paramCount && *text != '*'; ++i )
|
2008-11-08 06:44:07 +00:00
|
|
|
{
|
2010-11-30 20:41:35 +00:00
|
|
|
prim.params.push_back( AM_PARAM() );
|
2008-11-14 18:26:56 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
AM_PARAM& param = prim.params.back();
|
2008-11-09 02:57:42 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
text = GetNextLine( buff, text, gerber_file );
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2010-10-17 12:32:35 +00:00
|
|
|
if( text == NULL ) // End of File
|
2010-05-11 16:35:40 +00:00
|
|
|
return false;
|
2011-09-23 13:57:12 +00:00
|
|
|
|
2010-11-30 20:41:35 +00:00
|
|
|
param.ReadParam( text );
|
2008-11-08 06:44:07 +00:00
|
|
|
}
|
|
|
|
}
|
2008-12-16 02:20:21 +00:00
|
|
|
|
|
|
|
am.primitives.push_back( prim );
|
2007-09-25 15:10:01 +00:00
|
|
|
}
|
|
|
|
|
2008-11-08 06:44:07 +00:00
|
|
|
m_aperture_macros.insert( am );
|
|
|
|
|
|
|
|
return true;
|
2007-06-05 12:10:51 +00:00
|
|
|
}
|
2010-10-17 12:32:35 +00:00
|
|
|
|