DSN::SPECCTRA_DB Class Reference

A DSN data tree, usually coming from a DSN file. More...

#include <specctra.h>

Inheritance diagram for DSN::SPECCTRA_DB:

Public Member Functions
	SPECCTRA_DB ()
virtual	~SPECCTRA_DB ()
void	SetPCB (PCB *aPcb)
	Delete any existing PCB and replaces it with the given one. More...
PCB *	GetPCB ()
void	SetSESSION (SESSION *aSession)
	Delete any existing SESSION and replaces it with the given one. More...
SESSION *	GetSESSION ()
void	LoadPCB (const wxString &aFilename)
	A recursive descent parser for a SPECCTRA DSN "design" file. More...
void	LoadSESSION (const wxString &aFilename)
	A recursive descent parser for a SPECCTRA DSN "session" file. More...
void	ExportPCB (const wxString &aFilename, bool aNameChange=false)
	Write the internal PCB instance out as a SPECTRA DSN format file. More...
void	FromBOARD (BOARD *aBoard)
	Add the entire BOARD to the PCB but does not write it out. More...
void	FromSESSION (BOARD *aBoard)
	Add the entire #SESSION info to a BOARD but does not write it out. More...
void	ExportSESSION (const wxString &aFilename)
	Write the internal #SESSION instance out as a #SPECTRA DSN format file. More...
bool	BuiltBoardOutlines (BOARD *aBoard)
	Build the board outlines and store it in m_brd_outlines. More...
void	FlipFOOTPRINTs (BOARD *aBoard)
	Flip the footprints which are on the back side of the board to the front. More...
void	RevertFOOTPRINTs (BOARD *aBoard)
	Flip the footprints which were on the back side of the board back to the back. More...

Static Public Member Functions
static PCB *	MakePCB ()
	Make a PCB with all the default ELEMs and parts on the heap. More...

Private Member Functions
void	buildLayerMaps (BOARD *aBoard)
	Create a few data translation structures for layer name and number mapping between the DSN::PCB structure and the KiCad BOARD structure. More...
int	findLayerName (const std::string &aLayerName) const
	Return the PCB layer index for a given layer name, within the specctra sessionfile. More...
void	readCOMPnPIN (std::string *component_id, std::string *pid_id)
	Read a <pin_reference> and splits it into the two parts which are on either side of the hyphen. More...
void	readTIME (time_t *time_stamp)
	Read a <time_stamp> which consists of 8 lexer tokens: "month date hour : minute : second year". More...
void	doPCB (PCB *growth)
void	doPARSER (PARSER *growth)
void	doRESOLUTION (UNIT_RES *growth)
void	doUNIT (UNIT_RES *growth)
void	doSTRUCTURE (STRUCTURE *growth)
void	doSTRUCTURE_OUT (STRUCTURE_OUT *growth)
void	doLAYER_NOISE_WEIGHT (LAYER_NOISE_WEIGHT *growth)
void	doSPECCTRA_LAYER_PAIR (SPECCTRA_LAYER_PAIR *growth)
void	doBOUNDARY (BOUNDARY *growth)
void	doRECTANGLE (RECTANGLE *growth)
void	doPATH (PATH *growth)
void	doSTRINGPROP (STRINGPROP *growth)
void	doTOKPROP (TOKPROP *growth)
void	doVIA (VIA *growth)
void	doCONTROL (CONTROL *growth)
void	doLAYER (LAYER *growth)
void	doRULE (RULE *growth)
void	doKEEPOUT (KEEPOUT *growth)
void	doCIRCLE (CIRCLE *growth)
void	doQARC (QARC *growth)
void	doWINDOW (WINDOW *growth)
void	doCONNECT (CONNECT *growth)
void	doREGION (REGION *growth)
void	doCLASS_CLASS (CLASS_CLASS *growth)
void	doLAYER_RULE (LAYER_RULE *growth)
void	doCLASSES (CLASSES *growth)
void	doGRID (GRID *growth)
void	doPLACE (PLACE *growth)
void	doCOMPONENT (COMPONENT *growth)
void	doPLACEMENT (PLACEMENT *growth)
void	doPROPERTIES (PROPERTIES *growth)
void	doPADSTACK (PADSTACK *growth)
void	doSHAPE (SHAPE *growth)
void	doIMAGE (IMAGE *growth)
void	doLIBRARY (LIBRARY *growth)
void	doPIN (PIN *growth)
void	doNET (NET *growth)
void	doNETWORK (NETWORK *growth)
void	doCLASS (CLASS *growth)
void	doTOPOLOGY (TOPOLOGY *growth)
void	doFROMTO (FROMTO *growth)
void	doCOMP_ORDER (COMP_ORDER *growth)
void	doWIRE (WIRE *growth)
void	doWIRE_VIA (WIRE_VIA *growth)
void	doWIRING (WIRING *growth)
void	doSESSION (SESSION *growth)
void	doANCESTOR (ANCESTOR *growth)
void	doHISTORY (HISTORY *growth)
void	doROUTE (ROUTE *growth)
void	doWAS_IS (WAS_IS *growth)
void	doNET_OUT (NET_OUT *growth)
void	doSUPPLY_PIN (SUPPLY_PIN *growth)
void	fillBOUNDARY (BOARD *aBoard, BOUNDARY *aBoundary)
	Make the board perimeter for the DSN file by filling the BOUNDARY element in the specctra element tree. More...
IMAGE *	makeIMAGE (BOARD *aBoard, FOOTPRINT *aFootprint)
	Allocates an I::MAGE on the heap and creates all the PINs according to the PADs in the FOOTPRINT. More...
PADSTACK *	makePADSTACK (BOARD *aBoard, PAD *aPad)
	Create a #PADSTACK which matches the given pad. More...
PADSTACK *	makeVia (int aCopperDiameter, int aDrillDiameter, int aTopLayer, int aBotLayer)
	Make a round through hole #PADSTACK using the given KiCad diameter in deci-mils. More...
PADSTACK *	makeVia (const ::PCB_VIA *aVia)
	Make any kind of #PADSTACK using the given KiCad #VIA. More...
void	deleteNETs ()
	Delete all the NETs that may be in here. More...
void	exportNETCLASS (const std::shared_ptr< NETCLASS > &aNetClass, BOARD *aBoard)
	Export aNetClass to the DSN file. More...
PCB_TRACK *	makeTRACK (WIRE *wire, PATH *aPath, int aPointIndex, int aNetcode)
	Create a #TRACK form the #PATH and BOARD info. More...
PCB_VIA *	makeVIA (WIRE_VIA *aVia, PADSTACK *aPadstack, const POINT &aPoint, int aNetCode, int aViaDrillDefault)
	Instantiate a KiCad #VIA on the heap and initializes it with internal values consistent with the given #PADSTACK, #POINT, and netcode. More...

Private Attributes
PCB *	m_pcb
SHAPE_POLY_SET	m_brd_outlines
SESSION *	m_session
wxString	m_filename
std::string	m_quote_char
bool	m_footprintsAreFlipped
STRING_FORMATTER	m_sf
STRINGS	m_layerIds
	indexed by PCB layer number More...
std::vector< int >	m_kicadLayer2pcb
	maps BOARD layer number to PCB layer numbers More...
std::vector< PCB_LAYER_ID >	m_pcbLayer2kicad
	maps PCB layer number to BOARD layer numbers More...
UNIT_RES *	m_routeResolution
	used during FromSESSION() only, memory for it is not owned here. More...
BOARD *	m_sessionBoard
	a copy to avoid passing as an argument, memory for it is not owned here. More...
PADSTACKSET	m_padstackset
std::vector< NET * >	m_nets
	we don't want ownership here permanently, so we don't use boost::ptr_vector More...
int	m_top_via_layer
	specctra cu layers, 0 based index: More...
int	m_bot_via_layer

Static Private Attributes
static const KEYWORD	keywords []
	specctra DSN keywords More...
static const KICAD_T	scanPADs []

Detailed Description

A DSN data tree, usually coming from a DSN file.

Is essentially a SPECCTRA_PARSER class.

Definition at line 3647 of file specctra.h.

Constructor & Destructor Documentation

SPECCTRA_DB()

DSN::SPECCTRA_DB::SPECCTRA_DB ( )

inline

Definition at line 3651 of file specctra.h.

 :
 SPECCTRA_LEXER( 0 ) // LINE_READER* == nullptr, no DSNLEXER::PushReader()
 {
 // The LINE_READER will be pushed from an automatic instantiation,
 // we don't own it:
 wxASSERT( !iOwnReaders );
 
 m_pcb = 0;
 m_session = 0;
 m_quote_char += '"';
 m_footprintsAreFlipped = false;
 
 SetSpecctraMode( true );
 
 // Avoid not initialized members:
 m_routeResolution = nullptr;
 m_sessionBoard = nullptr;
 m_top_via_layer = 0;
 m_bot_via_layer = 0;
 }

References m_bot_via_layer, m_footprintsAreFlipped, m_pcb, m_quote_char, m_routeResolution, m_session, m_sessionBoard, and m_top_via_layer.

~SPECCTRA_DB()

virtual DSN::SPECCTRA_DB::~SPECCTRA_DB ( )

inlinevirtual

Definition at line 3672 of file specctra.h.

 {
 delete m_pcb;
 delete m_session;
 
 deleteNETs();
 }

References deleteNETs(), m_pcb, and m_session.

Member Function Documentation

buildLayerMaps()

void DSN::SPECCTRA_DB::buildLayerMaps ( BOARD *  aBoard )

private

Create a few data translation structures for layer name and number mapping between the DSN::PCB structure and the KiCad BOARD structure.

Parameters

aBoard

The BOARD to create the maps for.

Definition at line 76 of file specctra.cpp.

{
 // specctra wants top physical layer first, then going down to the
 // bottom most physical layer in physical sequence.
 // Same as KiCad now except for B_Cu
 unsigned layerCount = aBoard->GetCopperLayerCount();
 
 m_layerIds.clear();
 m_pcbLayer2kicad.resize( layerCount );
 m_kicadLayer2pcb.resize( B_Cu + 1 );
 
#if 0 // was:
 for( int kiNdx = layerCount - 1, pcbNdx=FIRST_LAYER; kiNdx >= 0; --kiNdx, ++pcbNdx )
 {
 int kilayer = (kiNdx>0 && kiNdx==layerCount-1) ? F_Cu : kiNdx;
 
 // establish bi-directional mapping between KiCad's BOARD layer and PCB layer
 pcbLayer2kicad[pcbNdx] = kilayer;
 kicadLayer2pcb[kilayer] = pcbNdx;
 
 // save the specctra layer name in SPECCTRA_DB::layerIds for later.
 layerIds.push_back( TO_UTF8( aBoard->GetLayerName( ToLAYER_ID( kilayer ) ) ) );
 }
#else
 
 // establish bi-directional mapping between KiCad's BOARD layer and PCB layer
 
 for( unsigned i = 0; i < m_kicadLayer2pcb.size(); ++i )
 {
 if( i < layerCount-1 )
 m_kicadLayer2pcb[i] = i;
 else
 m_kicadLayer2pcb[i] = layerCount - 1;
 }
 
 for( unsigned i = 0; i < m_pcbLayer2kicad.size(); ++i )
 {
 PCB_LAYER_ID id = ( i < layerCount-1 ) ? ToLAYER_ID( i ) : B_Cu;
 
 m_pcbLayer2kicad[i] = id;
 
 // save the specctra layer name in SPECCTRA_DB::layerIds for later.
 m_layerIds.push_back(TO_UTF8( aBoard->GetLayerName( id ) ) );
 }
 
#endif
}

References B_Cu, F_Cu, FIRST_LAYER, BOARD::GetCopperLayerCount(), BOARD::GetLayerName(), m_kicadLayer2pcb, m_layerIds, m_pcbLayer2kicad, TO_UTF8, and ToLAYER_ID().

Referenced by FromBOARD(), and FromSESSION().

BuiltBoardOutlines()

bool DSN::SPECCTRA_DB::BuiltBoardOutlines

(

BOARD *

aBoard

)

Build the board outlines and store it in m_brd_outlines.

Because it calls GetBoardPolygonOutlines() it must be called before flipping footprints

Returns

false if the board outlines cannot be built (not closed outlines)

Definition at line 232 of file specctra_export.cpp.

{
 return aBoard->GetBoardPolygonOutlines( m_brd_outlines );
}

References BOARD::GetBoardPolygonOutlines(), and m_brd_outlines.

Referenced by ExportBoardToSpecctraFile().

deleteNETs()

void DSN::SPECCTRA_DB::deleteNETs ( )

inlineprivate

Delete all the NETs that may be in here.

Definition at line 3945 of file specctra.h.

 {
 for( unsigned n = 0; n < m_nets.size(); ++n )
 delete m_nets[n];
 
 m_nets.clear();
 }

References m_nets.

Referenced by FromBOARD(), and ~SPECCTRA_DB().

doANCESTOR()

void DSN::SPECCTRA_DB::doANCESTOR ( ANCESTOR *  growth )

private

Definition at line 3275 of file specctra.cpp.

{
 T tok;
 
 /* <ancestor_file_descriptor >::=
 (ancestor <file_path_name> (created_time <time_stamp> )
 [(comment <comment_string> )])
 */
 
 NeedSYMBOL();
 growth->filename = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_created_time:
 readTIME( &growth->time_stamp );
 NeedRIGHT();
 break;
 
 case T_comment:
 NeedSYMBOL();
 growth->comment = CurText();
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::ANCESTOR::comment, DSN::ANCESTOR::filename, readTIME(), and DSN::ANCESTOR::time_stamp.

Referenced by doHISTORY().

doBOUNDARY()

void DSN::SPECCTRA_DB::doBOUNDARY ( BOUNDARY *  growth )

private

Definition at line 1036 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 if( tok == T_rect )
 {
 if( growth->paths.size() )
 Unexpected( "rect when path already encountered" );
 
 growth->rectangle = new RECTANGLE( growth );
 doRECTANGLE( growth->rectangle );
 NeedRIGHT();
 }
 else if( tok == T_path )
 {
 if( growth->rectangle )
 Unexpected( "path when rect already encountered" );
 
 for(;;)
 {
 if( tok != T_path )
 Expecting( T_path );
 
 PATH* path = new PATH( growth, T_path );
 growth->paths.push_back( path );
 
 doPATH( path );
 
 tok = NextTok();
 if( tok == T_RIGHT )
 break;
 
 if( tok != T_LEFT )
 Expecting(T_LEFT);
 
 tok = NextTok();
 }
 }
 else
 {
 Expecting( "rect|path" );
 }
}

References doPATH(), doRECTANGLE(), path, DSN::BOUNDARY::paths, RECTANGLE, and DSN::BOUNDARY::rectangle.

Referenced by doSTRUCTURE().

doCIRCLE()

void DSN::SPECCTRA_DB::doCIRCLE ( CIRCLE *  growth )

private

Definition at line 1166 of file specctra.cpp.

{
 T tok;
 
 NeedSYMBOLorNUMBER();
 growth->layer_id = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->diameter = strtod( CurText(), 0 );
 
 tok = NextTok();
 
 if( tok == T_NUMBER )
 {
 growth->vertex.x = strtod( CurText(), 0 );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->vertex.y = strtod( CurText(), 0 );
 
 tok = NextTok();
 }
 
 if( tok != T_RIGHT )
 Expecting( T_RIGHT );
}

References DSN::CIRCLE::diameter, DSN::CIRCLE::layer_id, DSN::CIRCLE::vertex, DSN::POINT::x, and DSN::POINT::y.

Referenced by doKEEPOUT(), doSHAPE(), doWINDOW(), and doWIRE().

doCLASS()

void DSN::SPECCTRA_DB::doCLASS ( CLASS *  growth )

private

Definition at line 2697 of file specctra.cpp.

{
 T tok;
 
 /* <class_descriptor >::=
 (class
 <class_id > {[{<net_id >} | {<composite_name_list> }]}
 [<circuit_descriptor> ]
 [<rule_descriptor> ]
 [{<layer_rule_descriptor> }]
 [<topology_descriptor> ]
 )
 */
 
 NeedSYMBOL();
 
 growth->class_id = CurText();
 
 // do net_ids, do not support <composite_name_list>s at this time
 while( IsSymbol( tok = NextTok() ) )
 {
 growth->net_ids.push_back( CurText() );
 }
 
 
 while( tok != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_layer_rule:
 LAYER_RULE* layer_rule;
 layer_rule = new LAYER_RULE( growth );
 growth->layer_rules.push_back( layer_rule );
 doLAYER_RULE( layer_rule );
 break;
 
 case T_topology:
 if( growth->topology )
 Unexpected( tok );
 
 growth->topology = new TOPOLOGY( growth );
 doTOPOLOGY( growth->topology );
 break;
 
 case T_circuit: // handle all the circuit_descriptor here as strings
 {
 std::string builder;
 int bracketNesting = 1; // we already saw the opening T_LEFT
 tok = T_NONE;
 
 while( bracketNesting != 0 && tok != T_EOF )
 {
 tok = NextTok();
 
 if( tok == T_LEFT )
 ++bracketNesting;
 else if( tok == T_RIGHT )
 --bracketNesting;
 
 if( bracketNesting >= 1 )
 {
 T previousTok = (T) PrevTok();
 
 if( previousTok != T_LEFT && previousTok != T_circuit && tok != T_RIGHT )
 builder += ' ';
 
 if( tok == T_STRING )
 builder += m_quote_char;
 
 builder += CurText();
 
 if( tok == T_STRING )
 builder += m_quote_char;
 }
 
 // When the nested rule is closed with a T_RIGHT and we are back down
 // to bracketNesting == 0, then save the builder and break;
 if( bracketNesting == 0 )
 {
 growth->circuit.push_back( builder );
 break;
 }
 }
 
 if( tok == T_EOF )
 Unexpected( T_EOF );
 
 break;
 } // scope bracket
 
 default:
 Unexpected( CurText() );
 } // switch
 
 tok = NextTok();
 
 } // while
}

References DSN::CLASS::circuit, DSN::CLASS::class_id, doLAYER_RULE(), doRULE(), doTOPOLOGY(), DSN::CLASS::layer_rules, m_quote_char, DSN::CLASS::net_ids, RULE, DSN::CLASS::rules, and DSN::CLASS::topology.

Referenced by doNETWORK().

doCLASS_CLASS()

void DSN::SPECCTRA_DB::doCLASS_CLASS ( CLASS_CLASS *  growth )

private

Definition at line 1702 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 switch( tok )
 {
 case T_classes:
 if( growth->classes )
 Unexpected( tok );
 
 growth->classes = new CLASSES( growth );
 doCLASSES( growth->classes );
 break;
 
 case T_rule:
 // only T_class_class takes a T_rule
 if( growth->Type() == T_region_class_class )
 Unexpected( tok );
 
 RULE* rule;
 rule = new RULE( growth, T_rule );
 growth->Append( rule );
 doRULE( rule );
 break;
 
 case T_layer_rule:
 // only T_class_class takes a T_layer_rule
 if( growth->Type() == T_region_class_class )
 Unexpected( tok );
 
 LAYER_RULE* layer_rule;
 layer_rule = new LAYER_RULE( growth );
 growth->Append( layer_rule );
 doLAYER_RULE( layer_rule );
 break;
 
 default:
 Unexpected( tok );
 }
 }
}

References DSN::ELEM_HOLDER::Append(), DSN::CLASS_CLASS::classes, doCLASSES(), doLAYER_RULE(), doRULE(), RULE, and DSN::ELEM::Type().

Referenced by doREGION().

doCLASSES()

void DSN::SPECCTRA_DB::doCLASSES ( CLASSES *  growth )

private

Definition at line 1750 of file specctra.cpp.

{
 T tok = NextTok();
 
 // require at least 2 class_ids
 
 if( !IsSymbol( tok ) )
 Expecting( "class_id" );
 
 growth->class_ids.push_back( CurText() );
 
 do
 {
 tok = NextTok();
 
 if( !IsSymbol( tok ) )
 Expecting( "class_id" );
 
 growth->class_ids.push_back( CurText() );
 
 } while( ( tok = NextTok() ) != T_RIGHT );
}

References DSN::CLASSES::class_ids.

Referenced by doCLASS_CLASS().

doCOMP_ORDER()

void DSN::SPECCTRA_DB::doCOMP_ORDER ( COMP_ORDER *  growth )

private

Definition at line 2856 of file specctra.cpp.

{
 T tok;
 
 /* <component_order_descriptor >::=
 (comp_order {<placement_id> })
 */
 
 while( IsSymbol( tok = NextTok() ) )
 {
 growth->placement_ids.push_back( CurText() );
 }
 
 if( tok != T_RIGHT )
 Expecting( T_RIGHT );
}

References DSN::COMP_ORDER::placement_ids.

Referenced by doNET(), and doTOPOLOGY().

doCOMPONENT()

void DSN::SPECCTRA_DB::doCOMPONENT ( COMPONENT *  growth )

private

Definition at line 2011 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( !IsSymbol( tok ) && tok != T_NUMBER )
 Expecting( "image_id" );
 
 growth->image_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_place:
 PLACE* place;
 place = new PLACE( growth );
 growth->places.push_back( place );
 doPLACE( place );
 break;
 
 default:
 Unexpected( tok );
 }
 }
}

References doPLACE(), DSN::COMPONENT::image_id, PLACE, and DSN::COMPONENT::places.

Referenced by doPLACEMENT().

doCONNECT()

void DSN::SPECCTRA_DB::doCONNECT ( CONNECT *  growth )

private

Definition at line 942 of file specctra.cpp.

{
 /* from page 143 of specctra spec:
 
 (connect
 {(terminal <object_type> [<pin_reference> ])}
 )
 */
 
 T tok = NextTok();
 
 while( tok != T_RIGHT )
 {
 if( tok!=T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_terminal:
 // since we do not use the terminal information, simply toss it.
 while( ( tok = NextTok() ) != T_RIGHT && tok != T_EOF )
 ;
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 }
}

Referenced by doWIRE().

doCONTROL()

void DSN::SPECCTRA_DB::doCONTROL ( CONTROL *  growth )

private

Definition at line 1276 of file specctra.cpp.

{
 T tok;
 
 while( (tok = NextTok()) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_via_at_smd:
 tok = NextTok();
 
 if( tok!=T_on && tok!=T_off )
 Expecting( "on|off" );
 
 growth->via_at_smd = (tok==T_on);
 NeedRIGHT();
 break;
 
 case T_off_grid:
 case T_route_to_fanout_only:
 case T_force_to_terminal_point:
 case T_same_net_checking:
 case T_checking_trim_by_pin:
 case T_noise_calculation:
 case T_noise_accumulation:
 case T_include_pins_in_crosstalk:
 case T_bbv_ctr2ctr:
 case T_average_pair_length:
 case T_crosstalk_model:
 case T_roundoff_rotation:
 case T_microvia:
 case T_reroute_order_viols:
 TOKPROP* tokprop;
 tokprop = new TOKPROP( growth, tok );
 growth->Append( tokprop );
 doTOKPROP( tokprop );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::ELEM_HOLDER::Append(), doTOKPROP(), and DSN::CONTROL::via_at_smd.

Referenced by doSTRUCTURE().

doFROMTO()

void DSN::SPECCTRA_DB::doFROMTO ( FROMTO *  growth )

private

Definition at line 2874 of file specctra.cpp.

{
 T tok;
 
 /* <fromto_descriptor >::=
 {(fromto
 [<pin_reference> | <virtual_pin_descriptor> ] | <component_id >]
 [<pin_reference> | <virtual_pin_descriptor> | <component_id >]
 [(type [fix | normal | soft])]
 [(net <net_id >)]
 [<rule_descriptor> ]
 [<circuit_descriptor> ]
 [{<layer_rule_descriptor> }]
 )}
 */
 
 
 // read the first two grammar items in as 2 single tokens, i.e. do not
 // split apart the <pin_reference>s into 3 separate tokens. Do this by
 // turning off the string delimiter in the lexer.
 
 char old = SetStringDelimiter( 0 );
 
 if( !IsSymbol(NextTok() ) )
 {
 SetStringDelimiter( old );
 Expecting( T_SYMBOL );
 }
 
 growth->fromText = CurText();
 
 if( !IsSymbol(NextTok() ) )
 {
 SetStringDelimiter( old );
 Expecting( T_SYMBOL );
 }
 
 growth->toText = CurText();
 
 SetStringDelimiter( old );
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_type:
 tok = NextTok();
 
 if( tok != T_fix && tok != T_normal && tok != T_soft )
 Expecting( "fix|normal|soft" );
 
 growth->fromto_type = tok;
 NeedRIGHT();
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_layer_rule:
 LAYER_RULE* layer_rule;
 layer_rule = new LAYER_RULE( growth );
 growth->layer_rules.push_back( layer_rule );
 doLAYER_RULE( layer_rule );
 break;
 
 case T_net:
 if( growth->net_id.size() )
 Unexpected( tok );
 
 NeedSYMBOL();
 growth->net_id = CurText();
 NeedRIGHT();
 break;
 
 // circuit descriptor not supported at this time
 
 default:
 Unexpected( CurText() );
 }
 }
}

References doLAYER_RULE(), doRULE(), DSN::FROMTO::fromText, DSN::FROMTO::fromto_type, DSN::FROMTO::layer_rules, DSN::FROMTO::net_id, RULE, DSN::FROMTO::rules, and DSN::FROMTO::toText.

Referenced by doNET(), and doTOPOLOGY().

doGRID()

void DSN::SPECCTRA_DB::doGRID ( GRID *  growth )

private

Definition at line 1774 of file specctra.cpp.

{
 T tok = NextTok();
 
 switch( tok )
 {
 case T_via:
 case T_wire:
 case T_via_keepout:
 case T_snap:
 case T_place:
 growth->grid_type = tok;
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->dimension = strtod( CurText(), 0 );
 tok = NextTok();
 
 if( tok == T_LEFT )
 {
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok == T_direction )
 {
 if( growth->grid_type == T_place )
 Unexpected( tok );
 
 tok = NextTok();
 
 if( tok != T_x && tok != T_y )
 Unexpected( CurText() );
 
 growth->direction = tok;
 
 if( NextTok() != T_RIGHT )
 Expecting(T_RIGHT);
 }
 else if( tok == T_offset )
 {
 if( growth->grid_type == T_place )
 Unexpected( tok );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->offset = strtod( CurText(), 0 );
 
 if( NextTok() != T_RIGHT )
 Expecting( T_RIGHT );
 }
 else if( tok == T_image_type )
 {
 if( growth->grid_type != T_place )
 Unexpected( tok );
 
 tok = NextTok();
 
 if( tok != T_smd && tok != T_pin )
 Unexpected( CurText() );
 
 growth->image_type = tok;
 
 if( NextTok() != T_RIGHT )
 Expecting( T_RIGHT );
 }
 }
 }
 
 break;
 
 default:
 Unexpected( tok );
 }
}

References DSN::GRID::dimension, DSN::GRID::direction, DSN::GRID::grid_type, DSN::GRID::image_type, and DSN::GRID::offset.

Referenced by doSTRUCTURE().

doHISTORY()

void DSN::SPECCTRA_DB::doHISTORY ( HISTORY *  growth )

private

Definition at line 3314 of file specctra.cpp.

{
 T tok;
 
 /* <history_descriptor >::=
 (history [{<ancestor_file_descriptor> }] <self_descriptor> )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_ancestor:
 ANCESTOR* ancestor;
 ancestor = new ANCESTOR( growth );
 growth->ancestors.push_back( ancestor );
 doANCESTOR( ancestor );
 break;
 
 case T_self:
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_created_time:
 readTIME( &growth->time_stamp );
 NeedRIGHT();
 break;
 
 case T_comment:
 NeedSYMBOL();
 growth->comments.push_back( CurText() );
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
 
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::HISTORY::ancestors, DSN::HISTORY::comments, doANCESTOR(), readTIME(), and DSN::HISTORY::time_stamp.

Referenced by doSESSION().

doIMAGE()

void DSN::SPECCTRA_DB::doIMAGE ( IMAGE *  growth )

private

Definition at line 2301 of file specctra.cpp.

{
 T tok = NextTok();
 
 /* <image_descriptor >::=
 (image <image_id >
 [(side [front | back | both])]
 [<unit_descriptor> ]
 [<outline_descriptor> ]
 {(pin <padstack_id > [(rotate <rotation> )]
 [<reference_descriptor> | <pin_array_descriptor> ]
 [<user_property_descriptor> ])}
 [{<conductor_shape_descriptor> }]
 [{<conductor_via_descriptor> }]
 [<rule_descriptor> ]
 [<place_rule_descriptor> ]
 [{<keepout_descriptor> }]
 [<image_property_descriptor> ]
 )
 */
 
 if( !IsSymbol( tok ) && tok != T_NUMBER )
 Expecting( "image_id" );
 
 growth->image_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_side:
 tok = NextTok();
 
 if( tok != T_front && tok != T_back && tok != T_both )
 Expecting( "front|back|both" );
 
 growth->side = tok;
 NeedRIGHT();
 break;
 
 case T_outline:
 SHAPE* outline;
 outline = new SHAPE( growth, T_outline ); // use SHAPE for T_outline
 growth->Append( outline );
 doSHAPE( outline );
 break;
 
 case T_pin:
 PIN* pin;
 pin = new PIN( growth );
 growth->pins.push_back( pin );
 doPIN( pin );
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, tok );
 doRULE( growth->rules );
 break;
 
 case T_place_rule:
 if( growth->place_rules )
 Unexpected( tok );
 
 growth->place_rules = new RULE( growth, tok );
 doRULE( growth->place_rules );
 break;
 
 case T_keepout:
 case T_place_keepout:
 case T_via_keepout:
 case T_wire_keepout:
 case T_bend_keepout:
 case T_elongate_keepout:
 KEEPOUT* keepout;
 keepout = new KEEPOUT( growth, tok );
 growth->keepouts.push_back( keepout );
 doKEEPOUT( keepout );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::ELEM_HOLDER::Append(), doKEEPOUT(), doPIN(), doRULE(), doSHAPE(), doUNIT(), DSN::IMAGE::image_id, DSN::IMAGE::keepouts, PIN, pin, DSN::IMAGE::pins, DSN::IMAGE::place_rules, RULE, DSN::IMAGE::rules, DSN::IMAGE::side, and DSN::IMAGE::unit.

Referenced by doLIBRARY().

doKEEPOUT()

void DSN::SPECCTRA_DB::doKEEPOUT ( KEEPOUT *  growth )

private

Definition at line 843 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( IsSymbol(tok) )
 {
 growth->name = CurText();
 tok = NextTok();
 }
 
 if( tok!=T_LEFT )
 Expecting( T_LEFT );
 
 while( tok != T_RIGHT )
 {
 if( tok!=T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_sequence_number:
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->sequence_number = atoi( CurText() );
 NeedRIGHT();
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_place_rule:
 if( growth->place_rules )
 Unexpected( tok );
 
 growth->place_rules = new RULE( growth, T_place_rule );
 doRULE( growth->place_rules );
 break;
 
 case T_rect:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new RECTANGLE( growth );
 doRECTANGLE( (RECTANGLE*) growth->shape );
 break;
 
 case T_circle:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new CIRCLE( growth );
 doCIRCLE( (CIRCLE*) growth->shape );
 break;
 
 case T_polyline_path:
 tok = T_path;
 KI_FALLTHROUGH;
 
 case T_path:
 case T_polygon:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new PATH( growth, tok );
 doPATH( (PATH*) growth->shape );
 break;
 
 case T_qarc:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new QARC( growth );
 doQARC( (QARC*) growth->shape );
 break;
 
 case T_window:
 WINDOW* window;
 window = new WINDOW( growth );
 growth->windows.push_back( window );
 doWINDOW( window );
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 }
}

References CIRCLE, doCIRCLE(), doPATH(), doQARC(), doRECTANGLE(), doRULE(), doWINDOW(), KI_FALLTHROUGH, DSN::KEEPOUT::name, DSN::KEEPOUT::place_rules, RECTANGLE, RULE, DSN::KEEPOUT::rules, DSN::KEEPOUT::sequence_number, DSN::KEEPOUT::shape, and DSN::KEEPOUT::windows.

Referenced by doIMAGE(), and doSTRUCTURE().

doLAYER()

void DSN::SPECCTRA_DB::doLAYER ( LAYER *  growth )

private

Definition at line 1349 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( !IsSymbol( tok ) )
 Expecting( T_SYMBOL );
 
 growth->name = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_type:
 tok = NextTok();
 
 if( tok != T_signal && tok != T_power && tok != T_mixed && tok != T_jumper )
 Expecting( "signal|power|mixed|jumper" );
 
 growth->layer_type = tok;
 
 if( NextTok()!=T_RIGHT )
 Expecting(T_RIGHT);
 
 break;
 
 case T_rule:
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_property:
 doPROPERTIES( &growth->properties );
 break;
 
 case T_direction:
 tok = NextTok();
 
 switch( tok )
 {
 case T_horizontal:
 case T_vertical:
 case T_orthogonal:
 case T_positive_diagonal:
 case T_negative_diagonal:
 case T_diagonal:
 case T_off:
 growth->direction = tok;
 break;
 default:
 // the spec has an example show an abbreviation of the "horizontal" keyword. Ouch.
 if( !strcmp( "hori", CurText() ) )
 {
 growth->direction = T_horizontal;
 break;
 }
 else if( !strcmp( "vert", CurText() ) )
 {
 growth->direction = T_vertical;
 break;
 }
 
 Expecting( "horizontal|vertical|orthogonal|positive_diagonal|negative_diagonal|"
 "diagonal|off" );
 }
 
 if( NextTok() != T_RIGHT )
 Expecting( T_RIGHT );
 
 break;
 
 case T_cost:
 tok = NextTok();
 
 switch( tok )
 {
 case T_forbidden:
 case T_high:
 case T_medium:
 case T_low:
 case T_free:
 growth->cost = tok;
 break;
 case T_NUMBER:
 // store as negative so we can differentiate between
 // T (positive) and T_NUMBER (negative)
 growth->cost = -atoi( CurText() );
 break;
 default:
 Expecting( "forbidden|high|medium|low|free|<positive_integer>|-1" );
 }
 
 tok = NextTok();
 
 if( tok == T_LEFT )
 {
 if( NextTok() != T_type )
 Unexpected( CurText() );
 
 tok = NextTok();
 
 if( tok!=T_length && tok!=T_way )
 Expecting( "length|way" );
 
 growth->cost_type = tok;
 
 if( NextTok()!=T_RIGHT )
 Expecting( T_RIGHT );
 
 tok = NextTok();
 }
 
 if( tok != T_RIGHT )
 Expecting( T_RIGHT );
 
 break;
 
 case T_use_net:
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( !IsSymbol( tok ) )
 Expecting( T_SYMBOL );
 
 growth->use_net.push_back( CurText() );
 }
 
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::LAYER::cost, DSN::LAYER::cost_type, DSN::LAYER::direction, doPROPERTIES(), doRULE(), DSN::LAYER::layer_type, DSN::LAYER::name, DSN::LAYER::properties, RULE, DSN::LAYER::rules, and DSN::LAYER::use_net.

Referenced by doSTRUCTURE(), and doSTRUCTURE_OUT().

doLAYER_NOISE_WEIGHT()

void DSN::SPECCTRA_DB::doLAYER_NOISE_WEIGHT ( LAYER_NOISE_WEIGHT *  growth )

private

Definition at line 633 of file specctra.cpp.

{
 T tok;
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 if( NextTok() != T_layer_pair )
 Expecting( T_layer_pair );
 
 SPECCTRA_LAYER_PAIR* layer_pair = new SPECCTRA_LAYER_PAIR( growth );
 growth->layer_pairs.push_back( layer_pair );
 doSPECCTRA_LAYER_PAIR( layer_pair );
 }
}

References doSPECCTRA_LAYER_PAIR(), and DSN::LAYER_NOISE_WEIGHT::layer_pairs.

Referenced by doSTRUCTURE().

doLAYER_RULE()

void DSN::SPECCTRA_DB::doLAYER_RULE ( LAYER_RULE *  growth )

private

Definition at line 1851 of file specctra.cpp.

{
 T tok;
 
 NeedSYMBOL();
 
 do
 {
 growth->layer_ids.push_back( CurText() );
 
 } while( IsSymbol( tok = NextTok() ) );
 
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 if( NextTok() != T_rule )
 Expecting( T_rule );
 
 growth->rule = new RULE( growth, T_rule );
 doRULE( growth->rule );
 
 NeedRIGHT();
}

References doRULE(), DSN::LAYER_RULE::layer_ids, RULE, and DSN::LAYER_RULE::rule.

Referenced by doCLASS(), doCLASS_CLASS(), doFROMTO(), and doNET().

doLIBRARY()

void DSN::SPECCTRA_DB::doLIBRARY ( LIBRARY *  growth )

private

Definition at line 2454 of file specctra.cpp.

{
 T tok;
 
 /* <library_descriptor >::=
 (library
 [<unit_descriptor> ]
 {<image_descriptor> }
 [{<jumper_descriptor> }]
 {<padstack_descriptor> }
 {<via_array_template_descriptor> }
 [<directory_descriptor> ]
 [<extra_image_directory_descriptor> ]
 [{<family_family_descriptor> }]
 [{<image_image_descriptor> }]
 )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_padstack:
 PADSTACK* padstack;
 padstack = new PADSTACK();
 growth->AddPadstack( padstack );
 doPADSTACK( padstack );
 break;
 
 case T_image:
 IMAGE* image;
 image = new IMAGE( growth );
 growth->images.push_back( image );
 doIMAGE( image );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::LIBRARY::AddPadstack(), doIMAGE(), doPADSTACK(), doUNIT(), IMAGE, image, DSN::LIBRARY::images, and DSN::LIBRARY::unit.

Referenced by doPCB(), and doROUTE().

doNET()

void DSN::SPECCTRA_DB::doNET ( NET *  growth )

private

Definition at line 2510 of file specctra.cpp.

{
 T tok = NextTok();
 PIN_REFS* pin_refs;
 
 /* <net_descriptor >::=
 (net <net_id >
 [(unassigned)]
 [(net_number <integer >)]
 [(pins {<pin_reference> }) | (order {<pin_reference> })]
 [<component_order_descriptor> ]
 [(type [fix | normal])]
 [<user_property_descriptor> ]
 [<circuit_descriptor> ]
 [<rule_descriptor> ]
 [{<layer_rule_descriptor> }]
 [<fromto_descriptor> ]
 [(expose {<pin_reference> })]
 [(noexpose {<pin_reference> })]
 [(source {<pin_reference> })]
 [(load {<pin_reference> })]
 [(terminator {<pin_reference> })]
 [(supply [power | ground])]
 )
 */
 
 if( !IsSymbol( tok ) )
 Expecting( "net_id" );
 
 growth->net_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unassigned:
 growth->unassigned = true;
 NeedRIGHT();
 break;
 
 case T_net_number:
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->net_number = atoi( CurText() );
 NeedRIGHT();
 break;
 
 case T_pins:
 case T_order:
 growth->pins_type = tok;
 pin_refs = &growth->pins;
 goto L_pins;
 
 case T_expose:
 pin_refs = &growth->expose;
 goto L_pins;
 
 case T_noexpose:
 pin_refs = &growth->noexpose;
 goto L_pins;
 
 case T_source:
 pin_refs = &growth->source;
 goto L_pins;
 
 case T_load:
 pin_refs = &growth->load;
 goto L_pins;
 
 case T_terminator:
 pin_refs = &growth->terminator;
 //goto L_pins;
 
L_pins:
 {
 PIN_REF empty( growth );
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 // copy the empty one, then fill its copy later thru pin_ref.
 pin_refs->push_back( empty );
 
 PIN_REF* pin_ref = &pin_refs->back();
 
 readCOMPnPIN( &pin_ref->component_id, &pin_ref->pin_id );
 }
 }
 
 break;
 
 case T_comp_order:
 if( growth->comp_order )
 Unexpected( tok );
 
 growth->comp_order = new COMP_ORDER( growth );
 doCOMP_ORDER( growth->comp_order );
 break;
 
 case T_type:
 tok = NextTok();
 
 if( tok!=T_fix && tok!=T_normal )
 Expecting( "fix|normal" );
 
 growth->type = tok;
 NeedRIGHT();
 break;
 
/* @todo
 case T_circuit:
 break;
*/
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_layer_rule:
 LAYER_RULE* layer_rule;
 layer_rule = new LAYER_RULE( growth );
 growth->layer_rules.push_back( layer_rule );
 doLAYER_RULE( layer_rule );
 break;
 
 case T_fromto:
 FROMTO* fromto;
 fromto = new FROMTO( growth );
 growth->fromtos.push_back( fromto );
 doFROMTO( fromto );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::NET::comp_order, DSN::PIN_REF::component_id, doCOMP_ORDER(), doFROMTO(), doLAYER_RULE(), doRULE(), empty(), DSN::NET::expose, DSN::NET::fromtos, DSN::NET::layer_rules, DSN::NET::load, DSN::NET::net_id, DSN::NET::net_number, DSN::NET::noexpose, DSN::PIN_REF::pin_id, DSN::NET::pins, DSN::NET::pins_type, readCOMPnPIN(), RULE, DSN::NET::rules, DSN::NET::source, DSN::NET::terminator, DSN::NET::type, and DSN::NET::unassigned.

Referenced by doNETWORK().

doNET_OUT()

void DSN::SPECCTRA_DB::doNET_OUT ( NET_OUT *  growth )

private

Definition at line 3587 of file specctra.cpp.

{
 T tok;
 
 /* <net_out_descriptor >::=
 (net <net_id >
 [(net_number <integer >)]
 [<rule_descriptor> ]
 {[<wire_shape_descriptor> | <wire_guide_descriptor> |
 <wire_via_descriptor> | <bond_shape_descriptor> ]}
 {[<supply_pin_descriptor> ]}
 )
 */
 
 NeedSYMBOLorNUMBER();
 growth->net_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_net_number:
 tok = NextTok();
 
 if( tok!= T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->net_number = atoi( CurText() );
 NeedRIGHT();
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, tok );
 doRULE( growth->rules );
 break;
 
 case T_wire:
 WIRE* wire;
 wire = new WIRE( growth );
 growth->wires.push_back( wire );
 doWIRE( wire );
 break;
 
 case T_via:
 WIRE_VIA* wire_via;
 wire_via = new WIRE_VIA( growth );
 growth->wire_vias.push_back( wire_via );
 doWIRE_VIA( wire_via );
 break;
 
 case T_supply_pin:
 SUPPLY_PIN* supply_pin;
 supply_pin = new SUPPLY_PIN( growth );
 growth->supply_pins.push_back( supply_pin );
 doSUPPLY_PIN( supply_pin );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References doRULE(), doSUPPLY_PIN(), doWIRE(), doWIRE_VIA(), DSN::NET_OUT::net_id, DSN::NET_OUT::net_number, RULE, DSN::NET_OUT::rules, DSN::NET_OUT::supply_pins, WIRE, DSN::NET_OUT::wire_vias, and DSN::NET_OUT::wires.

Referenced by doROUTE().

doNETWORK()

void DSN::SPECCTRA_DB::doNETWORK ( NETWORK *  growth )

private

Definition at line 2810 of file specctra.cpp.

{
 T tok;
 
 /* <network_descriptor >::=
 (network
 {<net_descriptor>}
 [{<class_descriptor> }]
 [{<class_class_descriptor> }]
 [{<group_descriptor> }]
 [{<group_set_descriptor> }]
 [{<pair_descriptor> }]
 [{<bundle_descriptor> }]
 )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_net:
 NET* net;
 net = new NET( growth );
 growth->nets.push_back( net );
 doNET( net );
 break;
 
 case T_class:
 CLASS* myclass;
 myclass = new CLASS( growth );
 growth->classes.push_back( myclass );
 doCLASS( myclass );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::NETWORK::classes, doCLASS(), doNET(), NET, and DSN::NETWORK::nets.

Referenced by doPCB().

doPADSTACK()

void DSN::SPECCTRA_DB::doPADSTACK ( PADSTACK *  growth )

private

Definition at line 2101 of file specctra.cpp.

{
 T tok = NextTok();
 
 /* (padstack <padstack_id >
 [<unit_descriptor> ]
 {(shape <shape_descriptor>
 [<reduced_shape_descriptor> ]
 [(connect [on | off])]
 [{<window_descriptor> }]
 )}
 [<attach_descriptor> ]
 [{<pad_via_site_descriptor> }]
 [(rotate [on | off])]
 [(absolute [on | off])]
 [(rule <clearance_descriptor> )])
 */
 
 // padstack_id may be a number
 if( !IsSymbol( tok ) && tok != T_NUMBER )
 Expecting( "padstack_id" );
 
 growth->padstack_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_rotate:
 tok = NextTok();
 
 if( tok != T_on && tok != T_off )
 Expecting( "on|off" );
 
 growth->rotate = tok;
 NeedRIGHT();
 break;
 
 case T_absolute:
 tok = NextTok();
 
 if( tok != T_on && tok != T_off )
 Expecting( "on|off" );
 
 growth->absolute = tok;
 NeedRIGHT();
 break;
 
 case T_shape:
 SHAPE* shape;
 shape = new SHAPE( growth );
 growth->Append( shape );
 doSHAPE( shape );
 break;
 
 case T_attach:
 tok = NextTok();
 
 if( tok != T_off && tok != T_on )
 Expecting( "off|on" );
 
 growth->attach = tok;
 tok = NextTok();
 
 if( tok == T_LEFT )
 {
 if( NextTok() != T_use_via )
 Expecting( T_use_via );
 
 NeedSYMBOL();
 growth->via_id = CurText();
 
 NeedRIGHT();
 NeedRIGHT();
 }
 
 break;
 
 /*
 case T_via_site: not supported
 break;
 */
 
 case T_rule:
 
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::PADSTACK::absolute, DSN::ELEM_HOLDER::Append(), DSN::PADSTACK::attach, doRULE(), doSHAPE(), doUNIT(), DSN::PADSTACK::padstack_id, DSN::PADSTACK::rotate, RULE, DSN::PADSTACK::rules, DSN::PADSTACK::unit, and DSN::PADSTACK::via_id.

Referenced by doLIBRARY().

doPARSER()

void DSN::SPECCTRA_DB::doPARSER ( PARSER *  growth )

private

Definition at line 412 of file specctra.cpp.

{
 T tok;
 std::string const1;
 std::string const2;
 
 /* <parser_descriptor >::=
 (parser
 [(string_quote <quote_char >)]
 (space_in_quoted_tokens [on | off])
 [(host_cad <id >)]
 [(host_version <id >)]
 [{(constant <id > <id >)}]
 [(write_resolution] {<character> <positive_integer >})]
 [(routes_include {[testpoint | guides |
 image_conductor]})]
 [(wires_include testpoint)]
 [(case_sensitive [on | off])]
 [(via_rotate_first [on | off])]
 )
 */
 
 while( (tok = NextTok()) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_STRING_QUOTE:
 tok = NextTok();
 
 if( tok != T_QUOTE_DEF )
 Expecting( T_QUOTE_DEF );
 
 SetStringDelimiter( (unsigned char) *CurText() );
 growth->string_quote = *CurText();
 m_quote_char = CurText();
 NeedRIGHT();
 break;
 
 case T_space_in_quoted_tokens:
 tok = NextTok();
 
 if( tok!=T_on && tok!=T_off )
 Expecting( "on|off" );
 
 SetSpaceInQuotedTokens( tok==T_on );
 growth->space_in_quoted_tokens = (tok==T_on);
 NeedRIGHT();
 break;
 
 case T_host_cad:
 NeedSYMBOL();
 growth->host_cad = CurText();
 NeedRIGHT();
 break;
 
 case T_host_version:
 NeedSYMBOLorNUMBER();
 growth->host_version = CurText();
 NeedRIGHT();
 break;
 
 case T_constant:
 NeedSYMBOLorNUMBER();
 const1 = CurText();
 NeedSYMBOLorNUMBER();
 const2 = CurText();
 NeedRIGHT();
 growth->constants.push_back( const1 );
 growth->constants.push_back( const2 );
 break;
 
 case T_write_resolution: // [(writee_resolution {<character> <positive_integer >})]
 while( (tok = NextTok()) != T_RIGHT )
 {
 if( tok!=T_SYMBOL )
 Expecting( T_SYMBOL );
 
 tok = NextTok();
 
 if( tok!=T_NUMBER )
 Expecting( T_NUMBER );
 
 // @todo
 }
 
 break;
 
 case T_routes_include: // [(routes_include {[testpoint | guides | image_conductor]})]
 while( (tok = NextTok()) != T_RIGHT )
 {
 switch( tok )
 {
 case T_testpoint:
 growth->routes_include_testpoint = true;
 break;
 case T_guide:
 growth->routes_include_guides = true;
 break;
 case T_image_conductor:
 growth->routes_include_image_conductor = true;
 break;
 default:
 Expecting( "testpoint|guides|image_conductor" );
 }
 }
 
 break;
 
 case T_wires_include: // [(wires_include testpoint)]
 tok = NextTok();
 
 if( tok != T_testpoint )
 Expecting( T_testpoint );
 
 growth->routes_include_testpoint = true;
 NeedRIGHT();
 break;
 
 case T_case_sensitive:
 tok = NextTok();
 
 if( tok!=T_on && tok!=T_off )
 Expecting( "on|off" );
 
 growth->case_sensitive = (tok==T_on);
 NeedRIGHT();
 break;
 
 case T_via_rotate_first: // [(via_rotate_first [on | off])]
 tok = NextTok();
 
 if( tok!=T_on && tok!=T_off )
 Expecting( "on|off" );
 
 growth->via_rotate_first = (tok==T_on);
 NeedRIGHT();
 break;
 
 case T_generated_by_freeroute:
 growth->generated_by_freeroute = true;
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::PARSER::case_sensitive, DSN::PARSER::constants, DSN::PARSER::generated_by_freeroute, DSN::PARSER::host_cad, DSN::PARSER::host_version, m_quote_char, DSN::PARSER::routes_include_guides, DSN::PARSER::routes_include_image_conductor, DSN::PARSER::routes_include_testpoint, DSN::PARSER::space_in_quoted_tokens, DSN::PARSER::string_quote, and DSN::PARSER::via_rotate_first.

Referenced by doPCB(), and doROUTE().

doPATH()

void DSN::SPECCTRA_DB::doPATH ( PATH *  growth )

private

Definition at line 1086 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( !IsSymbol( tok ) && tok != T_NUMBER ) // a layer name can be like a number like +12
 Expecting( "layer_id" );
 
 growth->layer_id = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( "aperture_width" );
 
 growth->aperture_width = strtod( CurText(), nullptr );
 
 POINT ptTemp;
 
 tok = NextTok();
 
 do
 {
 if( tok != T_NUMBER )
 Expecting( T_NUMBER );
 
 ptTemp.x = strtod( CurText(), nullptr );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 ptTemp.y = strtod( CurText(), nullptr );
 
 growth->points.push_back( ptTemp );
 
 } while( ( tok = NextTok() ) != T_RIGHT && tok != T_LEFT );
 
 if( tok == T_LEFT )
 {
 if( NextTok() != T_aperture_type )
 Expecting( T_aperture_type );
 
 tok = NextTok();
 
 if( tok!=T_round && tok!=T_square )
 Expecting( "round|square" );
 
 growth->aperture_type = tok;
 
 NeedRIGHT();
 }
}

References DSN::PATH::aperture_type, DSN::PATH::aperture_width, DSN::PATH::layer_id, DSN::PATH::points, DSN::POINT::x, and DSN::POINT::y.

Referenced by doBOUNDARY(), doKEEPOUT(), doREGION(), doSHAPE(), doWINDOW(), and doWIRE().

doPCB()

void DSN::SPECCTRA_DB::doPCB ( PCB *  growth )

private

Definition at line 297 of file specctra.cpp.

{
 T tok;
 
 /* <design_descriptor >::=
 (pcb <pcb_id >
 [<parser_descriptor> ]
 [<capacitance_resolution_descriptor> ]
 [<conductance_resolution_descriptor> ]
 [<current_resolution_descriptor> ]
 [<inductance_resolution_descriptor> ]
 [<resistance_resolution_descriptor> ]
 [<resolution_descriptor> ]
 [<time_resolution_descriptor> ]
 [<voltage_resolution_descriptor> ]
 [<unit_descriptor> ]
 [<structure_descriptor> | <file_descriptor> ]
 [<placement_descriptor> | <file_descriptor> ]
 [<library_descriptor> | <file_descriptor> ]
 [<floor_plan_descriptor> | <file_descriptor> ]
 [<part_library_descriptor> | <file_descriptor> ]
 [<network_descriptor> | <file_descriptor> ]
 [<wiring_descriptor> ]
 [<color_descriptor> ]
 )
 */
 
 NeedSYMBOL();
 growth->pcbname = CurText();
 
 while( (tok = NextTok()) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_parser:
 if( growth->parser )
 Unexpected( tok );
 
 growth->parser = new PARSER( growth );
 doPARSER( growth->parser );
 break;
 
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_resolution:
 if( growth->resolution )
 Unexpected( tok );
 
 growth->resolution = new UNIT_RES( growth, tok );
 doRESOLUTION( growth->resolution );
 break;
 
 case T_structure:
 if( growth->structure )
 Unexpected( tok );
 
 growth->structure = new STRUCTURE( growth );
 doSTRUCTURE( growth->structure );
 break;
 
 case T_placement:
 if( growth->placement )
 Unexpected( tok );
 
 growth->placement = new PLACEMENT( growth );
  doPLACEMENT( growth->placement );
 break;
 
 case T_library:
 if( growth->library )
 Unexpected( tok );
 
 growth->library = new LIBRARY( growth );
 doLIBRARY( growth->library );
 break;
 
 case T_network:
 if( growth->network )
 Unexpected( tok );
 
 growth->network = new NETWORK( growth );
 doNETWORK( growth->network );
 break;
 
 case T_wiring:
 if( growth->wiring )
 Unexpected( tok );
 
 growth->wiring = new WIRING( growth );
 doWIRING( growth->wiring );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
 
 tok = NextTok();
 
 if( tok != T_EOF )
 Expecting( T_EOF );
}

References doLIBRARY(), doNETWORK(), doPARSER(), doPLACEMENT(), doRESOLUTION(), doSTRUCTURE(), doUNIT(), doWIRING(), DSN::PCB::library, DSN::PCB::network, DSN::PCB::parser, DSN::PCB::pcbname, DSN::PCB::placement, DSN::PCB::resolution, DSN::PCB::structure, DSN::PCB::unit, and DSN::PCB::wiring.

Referenced by LoadPCB().

doPIN()

void DSN::SPECCTRA_DB::doPIN ( PIN *  growth )

private

Definition at line 2403 of file specctra.cpp.

{
 T tok = NextTok();
 
 /* (pin <padstack_id > [(rotate <rotation> )]
 [<reference_descriptor> | <pin_array_descriptor> ]
 [<user_property_descriptor> ])
 */
 
 // a padstack_id may be a number
 if( !IsSymbol( tok ) && tok!=T_NUMBER )
 Expecting( "padstack_id" );
 
 growth->padstack_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok == T_LEFT )
 {
 tok = NextTok();
 
 if( tok != T_rotate )
 Expecting( T_rotate );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->SetRotation( strtod( CurText(), 0 ) );
 NeedRIGHT();
 }
 else
 {
 if( !IsSymbol( tok ) && tok != T_NUMBER )
 Expecting( "pin_id" );
 
 growth->pin_id = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->vertex.x = strtod( CurText(), 0 );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->vertex.y = strtod( CurText(), 0 );
 }
 }
}

References DSN::PIN::padstack_id, DSN::PIN::pin_id, DSN::PIN::SetRotation(), DSN::PIN::vertex, DSN::POINT::x, and DSN::POINT::y.

Referenced by doIMAGE().

doPLACE()

void DSN::SPECCTRA_DB::doPLACE ( PLACE *  growth )

private

Definition at line 1876 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( !IsSymbol( tok ) )
 Expecting( "component_id" );
 
 growth->component_id = CurText();
 
 tok = NextTok();
 
 if( tok == T_NUMBER )
 {
 POINT point;
 
 point.x = strtod( CurText(), 0 );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 point.y = strtod( CurText(), 0 );
 
 growth->SetVertex( point );
 
 tok = NextTok();
 
 if( tok != T_front && tok != T_back )
 Expecting( "front|back" );
 
 growth->side = tok;
 
 if( NextTok() != T_NUMBER )
 Expecting( "rotation" );
 
 growth->SetRotation( strtod( CurText(), 0 ) );
 }
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_mirror:
 tok = NextTok();
 
 if( tok == T_x || tok == T_y || tok == T_xy || tok == T_off )
 growth->mirror = tok;
 else
 Expecting( "x|y|xy|off" );
 
 break;
 
 case T_status:
 tok = NextTok();
 
 if( tok==T_added || tok==T_deleted || tok==T_substituted )
 growth->status = tok;
 else
 Expecting("added|deleted|substituted");
 
 break;
 
 case T_logical_part:
 if( growth->logical_part.size() )
 Unexpected( tok );
 
 tok = NextTok();
 
 if( !IsSymbol( tok ) )
 Expecting( "logical_part_id");
 
 growth->logical_part = CurText();
 break;
 
 case T_place_rule:
 if( growth->place_rules )
 Unexpected( tok );
 
 growth->place_rules = new RULE( growth, T_place_rule );
 doRULE( growth->place_rules );
 break;
 
 case T_property:
 if( growth->properties.size() )
 Unexpected( tok );
 
 doPROPERTIES( &growth->properties );
 break;
 
 case T_lock_type:
 tok = NextTok();
 
 if( tok == T_position || tok == T_gate || tok == T_subgate || tok == T_pin )
 growth->lock_type = tok;
 else
 Expecting( "position|gate|subgate|pin" );
 
 break;
 
 case T_rule:
 if( growth->rules || growth->region )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_region:
 if( growth->rules || growth->region )
 Unexpected( tok );
 
 growth->region = new REGION( growth );
 doREGION( growth->region );
 break;
 
 case T_pn:
 if( growth->part_number.size() )
 Unexpected( tok );
 
 NeedSYMBOLorNUMBER();
 growth->part_number = CurText();
 NeedRIGHT();
 break;
 
 default:
 Unexpected( tok );
 }
 }
}

References DSN::PLACE::component_id, doPROPERTIES(), doREGION(), doRULE(), DSN::PLACE::lock_type, DSN::PLACE::logical_part, DSN::PLACE::mirror, DSN::PLACE::part_number, DSN::PLACE::place_rules, DSN::PLACE::properties, REGION, DSN::PLACE::region, RULE, DSN::PLACE::rules, DSN::PLACE::SetRotation(), DSN::PLACE::SetVertex(), DSN::PLACE::side, DSN::PLACE::status, DSN::POINT::x, and DSN::POINT::y.

Referenced by doCOMPONENT().

doPLACEMENT()

void DSN::SPECCTRA_DB::doPLACEMENT ( PLACEMENT *  growth )

private

Definition at line 2043 of file specctra.cpp.

{
 T tok;
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok == T_EOF )
 Unexpected( T_EOF );
 
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 case T_resolution:
 growth->unit = new UNIT_RES( growth, tok );
 
 if( tok == T_resolution )
 doRESOLUTION( growth->unit );
 else
 doUNIT( growth->unit );
 break;
 
 case T_place_control:
 NeedRIGHT();
 tok = NextTok();
 
 if( tok != T_flip_style )
  Expecting( T_flip_style );
 
 tok = NextTok();
 
 if( tok == T_mirror_first || tok == T_rotate_first )
 growth->flip_style = tok;
 else
 Expecting( "mirror_first|rotate_first" );
 
 NeedRIGHT();
 NeedRIGHT();
 break;
 
 case T_component:
 COMPONENT* component;
 component = new COMPONENT( growth );
 growth->components.push_back( component );
 doCOMPONENT( component );
 break;
 
 default:
 Unexpected( tok );
 }
 }
}

References COMPONENT, DSN::PLACEMENT::components, doCOMPONENT(), doRESOLUTION(), doUNIT(), DSN::PLACEMENT::flip_style, and DSN::PLACEMENT::unit.

Referenced by doPCB(), and doSESSION().

doPROPERTIES()

void DSN::SPECCTRA_DB::doPROPERTIES ( PROPERTIES *  growth )

private

Definition at line 1326 of file specctra.cpp.

{
 T tok;
 PROPERTY property; // construct it once here, append multiple times.
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 NeedSYMBOLorNUMBER();
 property.name = CurText();
 
 NeedSYMBOLorNUMBER();
 property.value = CurText();
 
 growth->push_back( property );
 
 NeedRIGHT();
 }
}

Referenced by doLAYER(), and doPLACE().

doQARC()

void DSN::SPECCTRA_DB::doQARC ( QARC *  growth )

private

Definition at line 1197 of file specctra.cpp.

{
 NeedSYMBOL();
 growth->layer_id = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->aperture_width = strtod( CurText(), 0 );
 
 for( int i = 0; i < 3; ++i )
 {
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->vertex[i].x = strtod( CurText(), 0 );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->vertex[i].y = strtod( CurText(), 0 );
 }
 
 NeedRIGHT();
}

References DSN::QARC::aperture_width, DSN::QARC::layer_id, DSN::QARC::vertex, DSN::POINT::x, and DSN::POINT::y.

Referenced by doKEEPOUT(), doSHAPE(), doWINDOW(), and doWIRE().

doRECTANGLE()

void DSN::SPECCTRA_DB::doRECTANGLE ( RECTANGLE *  growth )

private

Definition at line 1137 of file specctra.cpp.

{
 NeedSYMBOL();
 growth->layer_id = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->point0.x = strtod( CurText(), nullptr );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->point0.y = strtod( CurText(), nullptr );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->point1.x = strtod( CurText(), nullptr );
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->point1.y = strtod( CurText(), nullptr );
 
 NeedRIGHT();
}

References DSN::RECTANGLE::layer_id, DSN::RECTANGLE::point0, DSN::RECTANGLE::point1, DSN::POINT::x, and DSN::POINT::y.

Referenced by doBOUNDARY(), doKEEPOUT(), doREGION(), doSHAPE(), doWINDOW(), and doWIRE().

doREGION()

void DSN::SPECCTRA_DB::doREGION ( REGION *  growth )

private

Definition at line 1627 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( IsSymbol( tok ) )
 {
 growth->region_id = CurText();
 tok = NextTok();
 }
 
 for(;;)
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_rect:
 if( growth->rectangle )
 Unexpected( tok );
 
 growth->rectangle = new RECTANGLE( growth );
 doRECTANGLE( growth->rectangle );
 break;
 
 case T_polygon:
 if( growth->polygon )
 Unexpected( tok );
 
 growth->polygon = new PATH( growth, T_polygon );
 doPATH( growth->polygon );
 break;
 
 case T_region_net:
 case T_region_class:
 STRINGPROP* stringprop;
 stringprop = new STRINGPROP( growth, tok );
 growth->Append( stringprop );
  doSTRINGPROP( stringprop );
 break;
 
 case T_region_class_class:
 CLASS_CLASS* class_class;
 class_class = new CLASS_CLASS( growth, tok );
 growth->Append( class_class );
 doCLASS_CLASS( class_class );
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 
 if( tok == T_RIGHT )
 {
 if( !growth->rules )
 Expecting( T_rule );
 
 break;
 }
 }
}

References DSN::ELEM_HOLDER::Append(), doCLASS_CLASS(), doPATH(), doRECTANGLE(), doRULE(), doSTRINGPROP(), DSN::REGION::polygon, RECTANGLE, DSN::REGION::rectangle, DSN::REGION::region_id, RULE, and DSN::REGION::rules.

Referenced by doPLACE(), and doSTRUCTURE().

doRESOLUTION()

void DSN::SPECCTRA_DB::doRESOLUTION ( UNIT_RES *  growth )

private

Definition at line 567 of file specctra.cpp.

{
 T tok = NextTok();
 
 switch( tok )
 {
 case T_inch:
 case T_mil:
 case T_cm:
 case T_mm:
 case T_um:
 growth->units = tok;
 break;
 default:
 Expecting( "inch|mil|cm|mm|um" );
 }
 
 tok = NextTok();
 
 if( tok != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->value = atoi( CurText() );
 
 NeedRIGHT();
}

References DSN::UNIT_RES::units, and DSN::UNIT_RES::value.

Referenced by doPCB(), doPLACEMENT(), doROUTE(), doSTRUCTURE(), and doWIRING().

doROUTE()

void DSN::SPECCTRA_DB::doROUTE ( ROUTE *  growth )

private

Definition at line 3497 of file specctra.cpp.

{
 T tok;
 
 /* <route_descriptor >::=
 (routes
 <resolution_descriptor>
 <parser_descriptor>
 <structure_out_descriptor>
 <library_out_descriptor>
 <network_out_descriptor>
 <test_points_descriptor>
 )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
  tok = NextTok();
 
 switch( tok )
 {
 case T_resolution:
 if( growth->resolution )
 Unexpected( tok );
 
 growth->resolution = new UNIT_RES( growth, tok );
 doRESOLUTION( growth->resolution );
 break;
 
 case T_parser:
 if( growth->parser )
 {
#if 0 // Electra 2.9.1 emits two (parser ) elements in a row.
 // Work around their bug for now.
 Unexpected( tok );
#else
 delete growth->parser;
#endif
 }
 
 growth->parser = new PARSER( growth );
 doPARSER( growth->parser );
 break;
 
 case T_structure_out:
 if( growth->structure_out )
 Unexpected( tok );
 
 growth->structure_out = new STRUCTURE_OUT( growth );
 doSTRUCTURE_OUT( growth->structure_out );
 break;
 
 case T_library_out:
 if( growth->library )
 Unexpected( tok );
 
 growth->library = new LIBRARY( growth, tok );
 doLIBRARY( growth->library );
 break;
 
 case T_network_out:
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 if( tok != T_net ) // it is class NET_OUT, but token T_net
 Unexpected( CurText() );
 
 NET_OUT* net_out;
 net_out = new NET_OUT( growth );
 
 growth->net_outs.push_back( net_out );
 doNET_OUT( net_out );
 }
 
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References doLIBRARY(), doNET_OUT(), doPARSER(), doRESOLUTION(), doSTRUCTURE_OUT(), DSN::ROUTE::library, DSN::ROUTE::net_outs, DSN::ROUTE::parser, DSN::ROUTE::resolution, and DSN::ROUTE::structure_out.

Referenced by doSESSION().

doRULE()

void DSN::SPECCTRA_DB::doRULE ( RULE *  growth )

private

Definition at line 1489 of file specctra.cpp.

{
 std::string builder;
 int bracketNesting = 1; // we already saw the opening T_LEFT
 T tok = T_NONE;
 
 while( bracketNesting != 0 && tok != T_EOF )
 {
 tok = NextTok();
 
 if( tok==T_LEFT)
 ++bracketNesting;
 else if( tok==T_RIGHT )
 --bracketNesting;
 
 if( bracketNesting >= 1 )
 {
 if( PrevTok() != T_LEFT && tok != T_RIGHT && ( tok != T_LEFT || bracketNesting > 2 ) )
 builder += ' ';
 
 if( tok == T_STRING )
 builder += m_quote_char;
 
 builder += CurText();
 
 if( tok == T_STRING )
 builder += m_quote_char;
 }
 
 // When the nested rule is closed with a T_RIGHT and we are back down
 // to bracketNesting == 1, (inside the <rule_descriptor> but outside
 // the last rule). Then save the last rule and clear the string builder.
 if( bracketNesting == 1 )
 {
 growth->rules.push_back( builder );
 builder.clear();
 }
 }
 
 if( tok==T_EOF )
 Unexpected( T_EOF );
}

References m_quote_char, and DSN::RULE::rules.

Referenced by doCLASS(), doCLASS_CLASS(), doFROMTO(), doIMAGE(), doKEEPOUT(), doLAYER(), doLAYER_RULE(), doNET(), doNET_OUT(), doPADSTACK(), doPLACE(), doREGION(), doSTRUCTURE(), and doSTRUCTURE_OUT().

doSESSION()

void DSN::SPECCTRA_DB::doSESSION ( SESSION *  growth )

private

Definition at line 3373 of file specctra.cpp.

{
 T tok;
 
 /* <session_file_descriptor >::=
 (session <session_id >
 (base_design <path/filename >)
 [<history_descriptor> ]
 [<session_structure_descriptor> ]
 [<placement_descriptor> ]
 [<floor_plan_descriptor> ]
 [<net_pin_changes_descriptor> ]
 [<was_is_descriptor> ]
 <swap_history_descriptor> ]
 [<route_descriptor> ]
 )
 */
 
 NeedSYMBOL();
 growth->session_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_base_design:
 NeedSYMBOL();
 growth->base_design = CurText();
 NeedRIGHT();
 break;
 
 case T_history:
 if( growth->history )
 Unexpected( tok );
 
 growth->history = new HISTORY( growth );
  doHISTORY( growth->history );
 break;
 
 case T_structure:
 if( growth->structure )
 Unexpected( tok );
 
 growth->structure = new STRUCTURE( growth );
 doSTRUCTURE( growth->structure );
 break;
 
 case T_placement:
 if( growth->placement )
 Unexpected( tok );
 
 growth->placement = new PLACEMENT( growth );
 doPLACEMENT( growth->placement );
 break;
 
 case T_was_is:
 if( growth->was_is )
 Unexpected( tok );
 
 growth->was_is = new WAS_IS( growth );
 doWAS_IS( growth->was_is );
 break;
 
 case T_routes:
 if( growth->route )
 Unexpected( tok );
 
 growth->route = new ROUTE( growth );
 doROUTE( growth->route );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::SESSION::base_design, doHISTORY(), doPLACEMENT(), doROUTE(), doSTRUCTURE(), doWAS_IS(), DSN::SESSION::history, DSN::SESSION::placement, DSN::SESSION::route, DSN::SESSION::session_id, DSN::SESSION::structure, and DSN::SESSION::was_is.

Referenced by LoadSESSION().

doSHAPE()

void DSN::SPECCTRA_DB::doSHAPE ( SHAPE *  growth )

private

Definition at line 2213 of file specctra.cpp.

{
 T tok;
 
 /* (shape <shape_descriptor>
 [<reduced_shape_descriptor> ]
 [(connect [on | off])]
 [{<window_descriptor> }])
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_polyline_path:
 tok = T_path;
 KI_FALLTHROUGH;
 
 case T_rect:
 case T_circle:
 case T_path:
 case T_polygon:
 case T_qarc:
L_done_that:
 if( growth->shape )
 Unexpected( tok );
 
 break;
 
 default:
 // the example in the spec uses "circ" instead of "circle". Bad!
 if( !strcmp( "circ", CurText() ) )
 {
 tok = T_circle;
 goto L_done_that;
 }
 }
 
 switch( tok )
 {
 case T_rect:
 growth->shape = new RECTANGLE( growth );
 doRECTANGLE( (RECTANGLE*) growth->shape );
 break;
 
 case T_circle:
 growth->shape = new CIRCLE( growth );
 doCIRCLE( (CIRCLE*)growth->shape );
 break;
 
 case T_path:
 case T_polygon:
 growth->shape = new PATH( growth, tok );
 doPATH( (PATH*)growth->shape );
 break;
 
 case T_qarc:
 growth->shape = new QARC( growth );
 doQARC( (QARC*)growth->shape );
 break;
 
 case T_connect:
 tok = NextTok();
 if( tok!=T_on && tok!=T_off )
 Expecting( "on|off" );
 growth->connect = tok;
 NeedRIGHT();
 break;
 
 case T_window:
 WINDOW* window;
 window = new WINDOW( growth );
 growth->windows.push_back( window );
 doWINDOW( window );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References CIRCLE, DSN::SHAPE::connect, doCIRCLE(), doPATH(), doQARC(), doRECTANGLE(), doWINDOW(), KI_FALLTHROUGH, RECTANGLE, DSN::WINDOW::shape, and DSN::SHAPE::windows.

Referenced by doIMAGE(), and doPADSTACK().

doSPECCTRA_LAYER_PAIR()

void DSN::SPECCTRA_DB::doSPECCTRA_LAYER_PAIR ( SPECCTRA_LAYER_PAIR *  growth )

private

Definition at line 616 of file specctra.cpp.

{
 NeedSYMBOL();
 growth->layer_id0 = CurText();
 
 NeedSYMBOL();
 growth->layer_id1 = CurText();
 
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->layer_weight = strtod( CurText(), 0 );
 
 NeedRIGHT();
}

References DSN::SPECCTRA_LAYER_PAIR::layer_id0, DSN::SPECCTRA_LAYER_PAIR::layer_id1, and DSN::SPECCTRA_LAYER_PAIR::layer_weight.

Referenced by doLAYER_NOISE_WEIGHT().

doSTRINGPROP()

void DSN::SPECCTRA_DB::doSTRINGPROP ( STRINGPROP *  growth )

private

Definition at line 1224 of file specctra.cpp.

{
 NeedSYMBOL();
 growth->value = CurText();
 NeedRIGHT();
}

References DSN::STRINGPROP::value.

Referenced by doREGION(), and doSTRUCTURE().

doSTRUCTURE()

void DSN::SPECCTRA_DB::doSTRUCTURE ( STRUCTURE *  growth )

private

Definition at line 653 of file specctra.cpp.

{
 T tok;
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_resolution:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doRESOLUTION( growth->unit );
 break;
 
 case T_layer_noise_weight:
 if( growth->layer_noise_weight )
 Unexpected( tok );
 
 growth->layer_noise_weight = new LAYER_NOISE_WEIGHT( growth );
 doLAYER_NOISE_WEIGHT( growth->layer_noise_weight );
 break;
 
 case T_place_boundary:
L_place:
 if( growth->place_boundary )
 Unexpected( tok );
 
 growth->place_boundary = new BOUNDARY( growth, T_place_boundary );
 doBOUNDARY( growth->place_boundary );
 break;
 
 case T_boundary:
 if( growth->boundary )
 {
 if( growth->place_boundary )
 Unexpected( tok );
 
 goto L_place;
 }
 
 growth->boundary = new BOUNDARY( growth );
 doBOUNDARY( growth->boundary );
 break;
 
 case T_plane:
 COPPER_PLANE* plane;
 plane = new COPPER_PLANE( growth );
 growth->planes.push_back( plane );
 doKEEPOUT( plane );
 break;
 
 case T_region:
 REGION* region;
 region = new REGION( growth );
 growth->regions.push_back( region );
 doREGION( region );
 break;
 
 case T_snap_angle:
 STRINGPROP* stringprop;
 stringprop = new STRINGPROP( growth, T_snap_angle );
 growth->Append( stringprop );
 doSTRINGPROP( stringprop );
 break;
 
 case T_via:
 if( growth->via )
 Unexpected( tok );
 
 growth->via = new VIA( growth );
 doVIA( growth->via );
 break;
 
 case T_control:
 if( growth->control )
 Unexpected( tok );
 
 growth->control = new CONTROL( growth );
 doCONTROL( growth->control );
 break;
 
 case T_layer:
 LAYER* layer;
 layer = new LAYER( growth );
 growth->layers.push_back( layer );
 doLAYER( layer );
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 case T_place_rule:
 if( growth->place_rules )
 Unexpected( tok );
 
 growth->place_rules = new RULE( growth, T_place_rule );
 doRULE( growth->place_rules );
 break;
 
 case T_keepout:
 case T_place_keepout:
 case T_via_keepout:
 case T_wire_keepout:
 case T_bend_keepout:
 case T_elongate_keepout:
 KEEPOUT* keepout;
 keepout = new KEEPOUT( growth, tok );
 growth->keepouts.push_back( keepout );
 doKEEPOUT( keepout );
 break;
 
 case T_grid:
 GRID* grid;
 grid = new GRID( growth );
 growth->grids.push_back( grid );
 doGRID( grid );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::ELEM_HOLDER::Append(), DSN::STRUCTURE::boundary, DSN::STRUCTURE::control, doBOUNDARY(), doCONTROL(), doGRID(), doKEEPOUT(), doLAYER(), doLAYER_NOISE_WEIGHT(), doREGION(), doRESOLUTION(), doRULE(), doSTRINGPROP(), doUNIT(), doVIA(), grid, DSN::STRUCTURE::grids, DSN::STRUCTURE::keepouts, DSN::STRUCTURE::layer_noise_weight, DSN::STRUCTURE::layers, DSN::STRUCTURE::place_boundary, DSN::STRUCTURE::place_rules, DSN::STRUCTURE::planes, REGION, DSN::STRUCTURE::regions, RULE, DSN::STRUCTURE::rules, DSN::STRUCTURE::unit, VIA, and DSN::STRUCTURE::via.

Referenced by doPCB(), and doSESSION().

doSTRUCTURE_OUT()

void DSN::SPECCTRA_DB::doSTRUCTURE_OUT ( STRUCTURE_OUT *  growth )

private

Definition at line 798 of file specctra.cpp.

{
 /*
 <structure_out_descriptor >::=
 (structure_out
 {<layer_descriptor> }
 [<rule_descriptor> ]
 )
 */
 
 T tok = NextTok();
 
 while( tok != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_layer:
  LAYER* layer;
 layer = new LAYER( growth );
 growth->layers.push_back( layer );
 doLAYER( layer );
 break;
 
 case T_rule:
 if( growth->rules )
 Unexpected( tok );
 
 growth->rules = new RULE( growth, T_rule );
 doRULE( growth->rules );
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 }
}

References doLAYER(), doRULE(), DSN::STRUCTURE_OUT::layers, RULE, and DSN::STRUCTURE_OUT::rules.

Referenced by doROUTE().

doSUPPLY_PIN()

void DSN::SPECCTRA_DB::doSUPPLY_PIN ( SUPPLY_PIN *  growth )

private

Definition at line 3659 of file specctra.cpp.

{
 T tok;
 PIN_REF empty(growth);
 
 /* <supply_pin_descriptor >::=
 (supply_pin {<pin_reference> } [(net <net_id >)])
 */
 
 NeedSYMBOL();
 growth->net_id = CurText();
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( IsSymbol(tok) )
 {
 growth->pin_refs.push_back( empty );
 
 PIN_REF* pin_ref = &growth->pin_refs.back();
 
 readCOMPnPIN( &pin_ref->component_id, &pin_ref->pin_id );
 }
 else if( tok == T_LEFT )
 {
 tok = NextTok();
 
 if( tok != T_net )
 Expecting( T_net );
 
 growth->net_id = CurText();
 NeedRIGHT();
 }
 else
 Unexpected( CurText() );
 }
}

References DSN::PIN_REF::component_id, empty(), DSN::SUPPLY_PIN::net_id, DSN::PIN_REF::pin_id, DSN::SUPPLY_PIN::pin_refs, and readCOMPnPIN().

Referenced by doNET_OUT().

doTOKPROP()

void DSN::SPECCTRA_DB::doTOKPROP ( TOKPROP *  growth )

private

Definition at line 1232 of file specctra.cpp.

{
 T tok = NextTok();
 
 if( tok<0 )
 Unexpected( CurText() );
 
 growth->value = tok;
 
 NeedRIGHT();
}

References DSN::TOKPROP::value.

Referenced by doCONTROL().

doTOPOLOGY()

void DSN::SPECCTRA_DB::doTOPOLOGY ( TOPOLOGY *  growth )

private

Definition at line 2658 of file specctra.cpp.

{
 T tok;
 
 /* <topology_descriptor >::=
 (topology {[<fromto_descriptor> |
 <component_order_descriptor> ]})
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_fromto:
 FROMTO* fromto;
 fromto = new FROMTO( growth );
 growth->fromtos.push_back( fromto );
 doFROMTO( fromto );
 break;
 
 case T_comp_order:
 COMP_ORDER* comp_order;
 comp_order = new COMP_ORDER( growth );
 growth->comp_orders.push_back( comp_order );
 doCOMP_ORDER( comp_order );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::TOPOLOGY::comp_orders, doCOMP_ORDER(), doFROMTO(), and DSN::TOPOLOGY::fromtos.

Referenced by doCLASS().

doUNIT()

void DSN::SPECCTRA_DB::doUNIT ( UNIT_RES *  growth )

private

Definition at line 595 of file specctra.cpp.

{
 T tok = NextTok();
 
 switch( tok )
 {
 case T_inch:
 case T_mil:
 case T_cm:
 case T_mm:
 case T_um:
 growth->units = tok;
 break;
 default:
 Expecting( "inch|mil|cm|mm|um" );
 }
 
 NeedRIGHT();
}

References DSN::UNIT_RES::units.

Referenced by doIMAGE(), doLIBRARY(), doPADSTACK(), doPCB(), doPLACEMENT(), doSTRUCTURE(), and doWIRING().

doVIA()

void DSN::SPECCTRA_DB::doVIA ( VIA *  growth )

private

Definition at line 1245 of file specctra.cpp.

{
 T tok;
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok == T_LEFT )
 {
 if( NextTok() != T_spare )
 Expecting( T_spare );
 
 while( (tok = NextTok()) != T_RIGHT )
 {
 if( !IsSymbol( tok ) )
 Expecting( T_SYMBOL );
 
 growth->spares.push_back( CurText() );
 }
 }
 else if( IsSymbol( tok ) )
 {
 growth->padstacks.push_back( CurText() );
 }
 else
 {
 Unexpected( CurText() );
 }
 }
}

References DSN::VIA::padstacks, and DSN::VIA::spares.

Referenced by doSTRUCTURE().

doWAS_IS()

void DSN::SPECCTRA_DB::doWAS_IS ( WAS_IS *  growth )

private

Definition at line 3456 of file specctra.cpp.

{
 T tok;
 PIN_PAIR empty( growth );
 PIN_PAIR* pin_pair;
 
 /* <was_is_descriptor >::=
 (was_is {(pins <pin_reference> <pin_reference> )})
 */
 
 // none of the pins is ok too
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_pins:
 // copy the empty one, then fill its copy later thru pin_pair.
 growth->pin_pairs.push_back( empty );
 pin_pair= &growth->pin_pairs.back();
 
 NeedSYMBOL(); // readCOMPnPIN() expects 1st token to have been read
 readCOMPnPIN( &pin_pair->was.component_id, &pin_pair->was.pin_id );
 
 NeedSYMBOL(); // readCOMPnPIN() expects 1st token to have been read
 readCOMPnPIN( &pin_pair->is.component_id, &pin_pair->is.pin_id );
 
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::PIN_REF::component_id, empty(), DSN::PIN_PAIR::is, DSN::PIN_REF::pin_id, DSN::WAS_IS::pin_pairs, readCOMPnPIN(), and DSN::PIN_PAIR::was.

Referenced by doSESSION().

doWINDOW()

void DSN::SPECCTRA_DB::doWINDOW ( WINDOW *  growth )

private

Definition at line 977 of file specctra.cpp.

{
 T tok = NextTok();
 
 while( tok != T_RIGHT )
 {
 if( tok!=T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_rect:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new RECTANGLE( growth );
 doRECTANGLE( (RECTANGLE*) growth->shape );
 break;
 
 case T_circle:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new CIRCLE( growth );
 doCIRCLE( (CIRCLE*) growth->shape );
 break;
 
 case T_polyline_path:
 tok = T_path;
 KI_FALLTHROUGH;
 
 case T_path:
 case T_polygon:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new PATH( growth, tok );
 doPATH( (PATH*) growth->shape );
 break;
 
 case T_qarc:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new QARC( growth );
 doQARC( (QARC*) growth->shape );
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 }
}

References CIRCLE, doCIRCLE(), doPATH(), doQARC(), doRECTANGLE(), KI_FALLTHROUGH, RECTANGLE, and DSN::WINDOW::shape.

Referenced by doKEEPOUT(), doSHAPE(), and doWIRE().

doWIRE()

void DSN::SPECCTRA_DB::doWIRE ( WIRE *  growth )

private

Definition at line 2967 of file specctra.cpp.

{
 T tok;
 
 /* <wire_shape_descriptor >::=
 (wire
 <shape_descriptor>
 [(net <net_id >)]
 [(turret <turret#> )]
 [(type [fix | route | normal | protect])]
 [(attr [test | fanout | bus | jumper])]
 [(shield <net_id >)]
 [{<window_descriptor> }]
 [(connect
 (terminal <object_type> [<pin_reference> ])
 (terminal <object_type> [<pin_reference> ])
 )]
 [(supply)]
 )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_rect:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new RECTANGLE( growth );
 doRECTANGLE( (RECTANGLE*) growth->shape );
 break;
 
 case T_circle:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new CIRCLE( growth );
 doCIRCLE( (CIRCLE*) growth->shape );
 break;
 
 case T_polyline_path:
 tok = T_path;
 KI_FALLTHROUGH;
 
 case T_path:
 case T_polygon:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new PATH( growth, tok );
 doPATH( (PATH*) growth->shape );
 break;
 
 case T_qarc:
 if( growth->shape )
 Unexpected( tok );
 
 growth->shape = new QARC( growth );
 doQARC( (QARC*) growth->shape );
 break;
 
 case T_net:
 NeedSYMBOLorNUMBER();
 growth->net_id = CurText();
 NeedRIGHT();
 break;
 
  case T_turret:
 if( NextTok() != T_NUMBER )
 Expecting( T_NUMBER );
 
 growth->turret = atoi( CurText() );
 NeedRIGHT();
 break;
 
 case T_type:
 tok = NextTok();
 
 if( tok != T_fix && tok != T_route && tok != T_normal && tok != T_protect )
 Expecting( "fix|route|normal|protect" );
 
 growth->wire_type = tok;
 NeedRIGHT();
 break;
 
 case T_attr:
 tok = NextTok();
 
 if( tok != T_test && tok != T_fanout && tok != T_bus && tok != T_jumper )
 Expecting( "test|fanout|bus|jumper" );
 
 growth->attr = tok;
 NeedRIGHT();
 break;
 
 case T_shield:
 NeedSYMBOL();
 growth->shield = CurText();
 NeedRIGHT();
 break;
 
 case T_window:
 WINDOW* window;
 window = new WINDOW( growth );
 growth->windows.push_back( window );
 doWINDOW( window );
 break;
 
 case T_connect:
 if( growth->connect )
 Unexpected( tok );
 
 growth->connect = new CONNECT( growth );
 doCONNECT( growth->connect );
 break;
 
 case T_supply:
 growth->supply = true;
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References DSN::WIRE::attr, CIRCLE, DSN::WIRE::connect, doCIRCLE(), doCONNECT(), doPATH(), doQARC(), doRECTANGLE(), doWINDOW(), KI_FALLTHROUGH, DSN::WIRE::net_id, RECTANGLE, DSN::WIRE::shape, DSN::WIRE::shield, DSN::WIRE::supply, DSN::WIRE::turret, DSN::WIRE::windows, and DSN::WIRE::wire_type.

Referenced by doNET_OUT(), and doWIRING().

doWIRE_VIA()

void DSN::SPECCTRA_DB::doWIRE_VIA ( WIRE_VIA *  growth )

private

Definition at line 3101 of file specctra.cpp.

{
 T tok;
 POINT point;
 
 /* <wire_via_descriptor >::=
 (via
 <padstack_id > {<vertex> }
 [(net <net_id >)]
 [(via_number <via#> )]
 [(type [fix | route | normal | protect])]
 [(attr [test | fanout | jumper |
 virtual_pin <virtual_pin_name> ])]
 [(contact {<layer_id >})]
 [(supply)]
 )
 (virtual_pin
 <virtual_pin_name> <vertex> (net <net_id >)
 )
 */
 
 NeedSYMBOL();
 growth->padstack_id = CurText();
 
 while( ( tok = NextTok() ) == T_NUMBER )
 {
 point.x = strtod( CurText(), 0 );
 
 if( NextTok() != T_NUMBER )
 Expecting( "vertex.y" );
 
 point.y = strtod( CurText(), 0 );
 
 growth->vertexes.push_back( point );
 }
 
 while( tok != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_net:
 NeedSYMBOL();
 growth->net_id = CurText();
 NeedRIGHT();
 break;
 
 case T_via_number:
 if( NextTok() != T_NUMBER )
 Expecting( "<via#>" );
 
 growth->via_number = atoi( CurText() );
 NeedRIGHT();
 break;
 
 case T_type:
 tok = NextTok();
 
 if( tok != T_fix && tok != T_route && tok != T_normal && tok != T_protect )
 Expecting( "fix|route|normal|protect" );
 
 growth->via_type = tok;
 NeedRIGHT();
 break;
 
 case T_attr:
 tok = NextTok();
 
 if( tok != T_test && tok != T_fanout && tok != T_jumper && tok != T_virtual_pin )
 Expecting( "test|fanout|jumper|virtual_pin" );
 
 growth->attr = tok;
 
 if( tok == T_virtual_pin )
 {
 NeedSYMBOL();
 growth->virtual_pin_name = CurText();
 }
 
 NeedRIGHT();
 break;
 
 case T_contact:
 NeedSYMBOL();
 tok = T_SYMBOL;
 
 while( IsSymbol( tok ) )
 {
 growth->contact_layers.push_back( CurText() );
 tok = NextTok();
 }
 
 if( tok != T_RIGHT )
 Expecting( T_RIGHT );
 
 break;
 
 case T_supply:
 growth->supply = true;
 NeedRIGHT();
 break;
 
 default:
 Unexpected( CurText() );
 }
 
 tok = NextTok();
 }
}

References DSN::WIRE_VIA::attr, DSN::WIRE_VIA::contact_layers, DSN::WIRE_VIA::net_id, DSN::WIRE_VIA::padstack_id, DSN::WIRE_VIA::supply, DSN::WIRE_VIA::vertexes, DSN::WIRE_VIA::via_number, DSN::WIRE_VIA::via_type, DSN::WIRE_VIA::virtual_pin_name, DSN::POINT::x, and DSN::POINT::y.

Referenced by doNET_OUT(), and doWIRING().

doWIRING()

void DSN::SPECCTRA_DB::doWIRING ( WIRING *  growth )

private

Definition at line 3216 of file specctra.cpp.

{
 T tok;
 
 /* <wiring_descriptor >::=
 (wiring
 [<unit_descriptor> | <resolution_descriptor> | null]
 {<wire_descriptor> }
 [<test_points_descriptor> ]
 {[<supply_pin_descriptor> ]}
 )
 */
 
 while( ( tok = NextTok() ) != T_RIGHT )
 {
 if( tok != T_LEFT )
 Expecting( T_LEFT );
 
 tok = NextTok();
 
 switch( tok )
 {
 case T_unit:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doUNIT( growth->unit );
 break;
 
 case T_resolution:
 if( growth->unit )
 Unexpected( tok );
 
 growth->unit = new UNIT_RES( growth, tok );
 doRESOLUTION( growth->unit );
 break;
 
 case T_wire:
 WIRE* wire;
 wire = new WIRE( growth );
 growth->wires.push_back( wire );
 doWIRE( wire );
 break;
 
 case T_via:
 WIRE_VIA* wire_via;
 wire_via = new WIRE_VIA( growth );
 growth->wire_vias.push_back( wire_via );
 doWIRE_VIA( wire_via );
 break;
 
 default:
 Unexpected( CurText() );
 }
 }
}

References doRESOLUTION(), doUNIT(), doWIRE(), doWIRE_VIA(), DSN::WIRING::unit, WIRE, DSN::WIRING::wire_vias, and DSN::WIRING::wires.

Referenced by doPCB().

exportNETCLASS()

void DSN::SPECCTRA_DB::exportNETCLASS ( const std::shared_ptr< NETCLASS > &  aNetClass, BOARD *  aBoard  )

private

Export aNetClass to the DSN file.

Definition at line 1715 of file specctra_export.cpp.

{
 /* From page 11 of specctra spec:
 *
 * Routing and Placement Rule Hierarchies
 *
 * Routing and placement rules can be defined at multiple levels of design
 * specification. When a routing or placement rule is defined for an object at
 * multiple levels, a predefined routing or placement precedence order
 * automatically determines which rule to apply to the object. The routing rule
 * precedence order is
 *
 * pcb < layer < class < class layer < group_set < group_set layer < net <
 * net layer < group < group layer < fromto < fromto layer < class_class <
 * class_class layer < padstack < region < class region < net region <
 * class_class region
 *
 * A pcb rule (global rule for the PCB design) has the lowest precedence in the
 * hierarchy. A class-to-class region rule has the highest precedence. Rules
 * set at one level of the hierarchy override conflicting rules set at lower
 * levels. The placement rule precedence order is
 *
 * pcb < image_set < image < component < super cluster < room <
 * room_image_set < family_family < image_image
 *
 * A pcb rule (global rule for the PCB design) has the lowest precedence in the
 * hierarchy. An image-to-image rule has the highest precedence. Rules set at
 * one level of the hierarchy override conflicting rules set at lower levels.
 */
 
 char text[256];
 
 CLASS* clazz = new CLASS( m_pcb->network );
 
 m_pcb->network->classes.push_back( clazz );
 
 // Freerouter creates a class named 'default' anyway, and if we try to use that we end up
 // with two 'default' via rules so use something else as the name of our default class.
 clazz->class_id = TO_UTF8( aNetClass->GetName() );
 
 for( NETINFO_ITEM* net : aBoard->GetNetInfo() )
 {
 if( net->GetNetClass()->GetName() == clazz->class_id )
 clazz->net_ids.push_back( TO_UTF8( net->GetNetname() ) );
 }
 
 clazz->rules = new RULE( clazz, T_rule );
 
 // output the track width.
 int trackWidth = aNetClass->GetTrackWidth();
 sprintf( text, "(width %.6g)", scale( trackWidth ) );
 clazz->rules->rules.push_back( text );
 
 // output the clearance.
 int clearance = aNetClass->GetClearance();
 sprintf( text, "(clearance %.6g)", scale( clearance ) + safetyMargin );
 clazz->rules->rules.push_back( text );
 
 if( aNetClass->GetName() == NETCLASS::Default )
 clazz->class_id = "kicad_default";
 
 // The easiest way to get the via name is to create a temporary via (which generates the
 // name internal to the PADSTACK), and then grab the name and delete the via. There are not
 // that many netclasses so this should never become a performance issue.
 
 PADSTACK* via = makeVia( aNetClass->GetViaDiameter(), aNetClass->GetViaDrill(),
 m_top_via_layer, m_bot_via_layer );
 
 snprintf( text, sizeof(text), "(use_via %s)", via->GetPadstackId().c_str() );
 clazz->circuit.push_back( text );
 
 delete via;
}

References DSN::CLASS::circuit, DSN::CLASS::class_id, DSN::NETWORK::classes, NETCLASS::Default, BOARD::GetNetInfo(), m_bot_via_layer, m_pcb, m_top_via_layer, makeVia(), DSN::CLASS::net_ids, DSN::PCB::network, DSN::RULE::rules, DSN::CLASS::rules, safetyMargin, DSN::scale(), text, TO_UTF8, and via.

Referenced by FromBOARD().

ExportPCB()

void DSN::SPECCTRA_DB::ExportPCB	(	const wxString &	aFilename,
		bool	aNameChange = false
	)

Write the internal PCB instance out as a SPECTRA DSN format file.

Parameters

aFilename	The file to save to.
aNameChange	If true, causes the pcb's name to change to "aFilename" and also to to be changed in the output file.

Exceptions

IO_ERROR,if

an i/o error occurs saving the file.

Definition at line 3697 of file specctra.cpp.

{
 if( m_pcb )
 {
 FILE_OUTPUTFORMATTER formatter( aFilename, wxT( "wt" ), m_quote_char[0] );
 
 if( aNameChange )
 m_pcb->pcbname = TO_UTF8( aFilename );
 
 m_pcb->Format( &formatter, 0 );
 }
}

References DSN::PCB::Format(), m_pcb, m_quote_char, DSN::PCB::pcbname, and TO_UTF8.

Referenced by ExportBoardToSpecctraFile().

ExportSESSION()

void DSN::SPECCTRA_DB::ExportSESSION

(

const wxString &

aFilename

)

Write the internal #SESSION instance out as a #SPECTRA DSN format file.

Parameters

aFilename

The file to save to.

Definition at line 3711 of file specctra.cpp.

{
 if( m_session )
 {
 FILE_OUTPUTFORMATTER formatter( aFilename, wxT( "wt" ), m_quote_char[0] );
 
 m_session->Format( &formatter, 0 );
 }
}

References DSN::SESSION::Format(), m_quote_char, and m_session.

fillBOUNDARY()

void DSN::SPECCTRA_DB::fillBOUNDARY ( BOARD *  aBoard, BOUNDARY *  aBoundary  )

private

Make the board perimeter for the DSN file by filling the BOUNDARY element in the specctra element tree.

Parameters

aBoard	The BOARD to get information from in order to make the BOUNDARY.
aBoundary	The empty BOUNDARY to fill in.

Definition at line 1030 of file specctra_export.cpp.

{
 for( int cnt = 0; cnt < m_brd_outlines.OutlineCount(); cnt++ ) // Should be one outline
 {
 PATH* path = new PATH( boundary );
 boundary->paths.push_back( path );
 path->layer_id = "pcb";
 
 SHAPE_LINE_CHAIN& outline = m_brd_outlines.Outline( cnt );
 
 for( int ii = 0; ii < outline.PointCount(); ii++ )
 {
 wxPoint pos( outline.CPoint( ii ).x, outline.CPoint( ii ).y );
 path->AppendPoint( mapPt( pos ) );
 }
 
 // Close polygon:
 wxPoint pos0( outline.CPoint( 0 ).x, outline.CPoint( 0 ).y );
 path->AppendPoint( mapPt( pos0 ) );
 
 // Generate holes as keepout:
 for( int ii = 0; ii < m_brd_outlines.HoleCount( cnt ); ii++ )
 {
 // emit a signal layers keepout for every interior polygon left...
 KEEPOUT* keepout = new KEEPOUT( nullptr, T_keepout );
 PATH* poly_ko = new PATH( nullptr, T_polygon );
 
 keepout->SetShape( poly_ko );
 poly_ko->SetLayerId( "signal" );
 m_pcb->structure->keepouts.push_back( keepout );
 
 SHAPE_LINE_CHAIN& hole = m_brd_outlines.Hole( cnt, ii );
 
 for( int jj = 0; jj < hole.PointCount(); jj++ )
 {
 wxPoint pos( hole.CPoint( jj ).x, hole.CPoint( jj ).y );
 poly_ko->AppendPoint( mapPt( pos ) );
 }
 
 // Close polygon:
 wxPoint pos( hole.CPoint( 0 ).x, hole.CPoint( 0 ).y );
 poly_ko->AppendPoint( mapPt( pos ) );
 }
 }
}

References DSN::PATH::AppendPoint(), SHAPE_LINE_CHAIN::CPoint(), SHAPE_POLY_SET::Hole(), SHAPE_POLY_SET::HoleCount(), DSN::STRUCTURE::keepouts, m_brd_outlines, m_pcb, DSN::mapPt(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), path, DSN::BOUNDARY::paths, SHAPE_LINE_CHAIN::PointCount(), DSN::PATH::SetLayerId(), DSN::KEEPOUT::SetShape(), DSN::PCB::structure, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by FromBOARD().

findLayerName()

int DSN::SPECCTRA_DB::findLayerName ( const std::string &  aLayerName ) const

private

Return the PCB layer index for a given layer name, within the specctra sessionfile.

Returns

the layer index within the specctra session file, or -1 if aLayerName is not found.

Definition at line 125 of file specctra.cpp.

{
 for( int i = 0; i < int( m_layerIds.size() ); ++i )
 {
 if( 0 == aLayerName.compare( m_layerIds[i] ) )
 return i;
 }
 
 return -1;
}

References m_layerIds.

Referenced by makeTRACK(), and makeVIA().

FlipFOOTPRINTs()

void DSN::SPECCTRA_DB::FlipFOOTPRINTs

(

BOARD *

aBoard

)

Flip the footprints which are on the back side of the board to the front.

Definition at line 1790 of file specctra_export.cpp.

{
 // DSN Images (=KiCad FOOTPRINTs and PADs) must be presented from the top view.
 // Note: to export footprints, the footprints must be flipped around the X axis, otherwise
 // the rotation angle is not good.
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 footprint->SetFlag( 0 );
 
 if( footprint->GetLayer() == B_Cu )
 {
 footprint->Flip( footprint->GetPosition(), false );
 footprint->SetFlag( 1 );
 }
 }
 
 m_footprintsAreFlipped = true;
}

References B_Cu, BOARD::Footprints(), and m_footprintsAreFlipped.

Referenced by ExportBoardToSpecctraFile().

FromBOARD()

void DSN::SPECCTRA_DB::FromBOARD

(

BOARD *

aBoard

)

Add the entire BOARD to the PCB but does not write it out.

Note

The BOARD given to this function must have all the FOOTPRINTs on the component side of the BOARD.

See also

PCB_EDIT_FRAME::ExportToSpecctra() for an example before calling this function.

Parameters

aBoard

The BOARD to convert to a PCB.

Definition at line 1081 of file specctra_export.cpp.

{
 std::shared_ptr<NET_SETTINGS>& netSettings = aBoard->GetDesignSettings().m_NetSettings;
 
 // Not all boards are exportable. Check that all reference Ids are unique, or we won't be
 // able to import the session file which comes back to us later from the router.
 {
 STRINGSET refs; // holds footprint reference designators
 
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 if( footprint->GetReference() == wxEmptyString )
 {
 THROW_IO_ERROR( wxString::Format( _( "Footprint with value of '%s' has an empty "
  "reference designator." ),
 footprint->GetValue() ) );
 }
 
 // if we cannot insert OK, that means the reference has been seen before.
 STRINGSET_PAIR refpair = refs.insert( TO_UTF8( footprint->GetReference() ) );
 
 if( !refpair.second ) // insert failed
 {
 THROW_IO_ERROR( wxString::Format( _( "Multiple footprints have the reference "
 "designator '%s'." ),
 footprint->GetReference() ) );
 }
 }
 }
 
 if( !m_pcb )
 m_pcb = SPECCTRA_DB::MakePCB();
 
 //-----<layer_descriptor>-----------------------------------------------
 {
 // Specctra wants top physical layer first, then going down to the bottom most physical
 // layer in physical sequence.
 
 buildLayerMaps( aBoard );
 
 int layerCount = aBoard->GetCopperLayerCount();
 
 for( int pcbNdx=0; pcbNdx<layerCount; ++pcbNdx )
 {
 LAYER* layer = new LAYER( m_pcb->structure );
 
 m_pcb->structure->layers.push_back( layer );
 
 layer->name = m_layerIds[pcbNdx];
 
 DSN_T layerType;
 
 switch( aBoard->GetLayerType( m_pcbLayer2kicad[pcbNdx] ) )
 {
 default:
 case LT_SIGNAL: layerType = T_signal; break;
 case LT_POWER: layerType = T_power; break;
 
 // Freerouter does not support type "mixed", only signal and power.
 // Remap "mixed" to "signal".
 case LT_MIXED: layerType = T_signal; break;
 case LT_JUMPER: layerType = T_jumper; break;
 }
 
 layer->layer_type = layerType;
 
 layer->properties.push_back( PROPERTY() );
 PROPERTY* property = &layer->properties.back();
 property->name = "index";
 char temp[32];
 sprintf( temp, "%d", pcbNdx );
 property->value = temp;
 }
 }
 
 // a space in a quoted token is NOT a terminator, true establishes this.
 m_pcb->parser->space_in_quoted_tokens = true;
 
 //-----<unit_descriptor> & <resolution_descriptor>--------------------
 {
 // Tell freerouter to use "tenths of micrometers", which is 100 nm resolution. Possibly
 // more resolution is possible in freerouter, but it would need testing.
 
 m_pcb->unit->units = T_um;
 m_pcb->resolution->units = T_um;
 m_pcb->resolution->value = 10; // tenths of a um
 }
 
 //-----<boundary_descriptor>------------------------------------------
 {
 // Because fillBOUNDARY() can throw an exception, we link in an empty boundary so the
 // BOUNDARY does not get lost in the event of of an exception.
 BOUNDARY* boundary = new BOUNDARY( 0 );
 
 m_pcb->structure->SetBOUNDARY( boundary );
 fillBOUNDARY( aBoard, boundary );
 }
 
 //-----<rules>--------------------------------------------------------
 {
 char rule[80];
 int defaultTrackWidth = netSettings->m_DefaultNetClass->GetTrackWidth();
 int defaultClearance = netSettings->m_DefaultNetClass->GetClearance();
 double clearance = scale( defaultClearance );
 
 STRINGS& rules = m_pcb->structure->rules->rules;
 
 sprintf( rule, "(width %.6g)", scale( defaultTrackWidth ) );
 rules.push_back( rule );
 
 sprintf( rule, "(clearance %.6g)", clearance + safetyMargin );
 rules.push_back( rule );
 
 // On a high density board (4 mil tracks, 4 mil spacing) a typical solder mask clearance
 // will be 2-3 mils. This exposes 2 to 3 mils of bare board around each pad, and would
 // leave only 1 to 2 mils of solder mask between the solder mask's boundary and the edge of
 // any trace within "clearance" of the pad. So we need at least 2 mils *extra* clearance
 // for traces which would come near a pad on a different net. So if the baseline trace to
 // trace clearance was 4 mils, then the SMD to trace clearance should be at least 6 mils.
 double default_smd = clearance + safetyMargin;
 
 if( default_smd <= 6.0 )
 default_smd = 6.0;
 
 sprintf( rule, "(clearance %.6g (type default_smd))", default_smd );
 
 rules.push_back( rule );
 
 // Pad to pad spacing on a single SMT part can be closer than our clearance. We don't want
 // freerouter complaining about that, so output a significantly smaller pad to pad
 // clearance to freerouter.
 clearance = scale( defaultClearance ) / 4;
 
 sprintf( rule, "(clearance %.6g (type smd_smd))", clearance );
 rules.push_back( rule );
 }
 
 //-----<zones (not keepout areas) become planes>--------------------------------
 // Note: only zones are output here, keepout areas are created later.
 {
 int netlessZones = 0;
 
 for( ZONE* zone : aBoard->Zones() )
 {
 if( zone->GetIsRuleArea() )
 continue;
 
 // Currently, we export only copper layers
 if( ! IsCopperLayer( zone->GetLayer() ) )
 continue;
 
 COPPER_PLANE* plane = new COPPER_PLANE( m_pcb->structure );
 
 m_pcb->structure->planes.push_back( plane );
 
 PATH* mainPolygon = new PATH( plane, T_polygon );
 
 plane->SetShape( mainPolygon );
 plane->name = TO_UTF8( zone->GetNetname() );
 
 if( plane->name.size() == 0 )
 {
 char name[32];
 
 // This is one of those no connection zones, netcode=0, and it has no name.
 // Create a unique, bogus netname.
 NET* no_net = new NET( m_pcb->network );
 
 sprintf( name, "@:no_net_%d", netlessZones++ );
 no_net->net_id = name;
 
 // add the bogus net name to network->nets.
 m_pcb->network->nets.push_back( no_net );
 
 // use the bogus net name in the netless zone.
 plane->name = no_net->net_id;
 }
 
 mainPolygon->layer_id = m_layerIds[ m_kicadLayer2pcb[ zone->GetLayer() ] ];
 
 // Handle the main outlines
 SHAPE_POLY_SET::ITERATOR iterator;
 wxPoint startpoint;
 bool is_first_point = true;
 
 for( iterator = zone->IterateWithHoles(); iterator; iterator++ )
 {
 wxPoint point( iterator->x, iterator->y );
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 mainPolygon->AppendPoint( mapPt( point ) );
 
 // this was the end of the main polygon
 if( iterator.IsEndContour() )
 {
 // Close polygon
 mainPolygon->AppendPoint( mapPt( startpoint ) );
 break;
 }
 }
 
 WINDOW* window = 0;
 PATH* cutout = 0;
 
 bool isStartContour = true;
 
 // handle the cutouts
 for( iterator++; iterator; iterator++ )
 {
 if( isStartContour )
 {
 is_first_point = true;
 window = new WINDOW( plane );
 plane->AddWindow( window );
 
 cutout = new PATH( window, T_polygon );
 window->SetShape( cutout );
 cutout->layer_id = m_layerIds[ m_kicadLayer2pcb[ zone->GetLayer() ] ];
 }
 
 // If the point in this iteration is the last of the contour, the next iteration
 // will start with a new contour.
 isStartContour = iterator.IsEndContour();
 
 wxASSERT( window );
 wxASSERT( cutout );
 
 wxPoint point(iterator->x, iterator->y );
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 cutout->AppendPoint( mapPt( point ) );
 
 // Close the polygon
 if( iterator.IsEndContour() )
 cutout->AppendPoint( mapPt( startpoint ) );
 }
 }
 }
 
 //-----<zones flagged keepout areas become keepout>--------------------------------
 {
 for( ZONE* zone : aBoard->Zones() )
 {
 if( !zone->GetIsRuleArea() )
 continue;
 
 // Keepout areas have a type: T_place_keepout, T_via_keepout, T_wire_keepout,
 // T_bend_keepout, T_elongate_keepout, T_keepout.
 // Pcbnew knows only T_keepout, T_via_keepout and T_wire_keepout
 DSN_T keepout_type;
 
 if( zone->GetDoNotAllowVias() && zone->GetDoNotAllowTracks() )
 keepout_type = T_keepout;
 else if( zone->GetDoNotAllowVias() )
 keepout_type = T_via_keepout;
 else if( zone->GetDoNotAllowTracks() )
 keepout_type = T_wire_keepout;
 else
 keepout_type = T_keepout;
 
 // Now, build keepout polygon on each copper layer where the zone
 // keepout is living (keepout zones can live on many copper layers)
 const int copperCount = aBoard->GetCopperLayerCount();
 
 for( int layer = 0; layer < copperCount; layer++ )
 {
 if( layer == copperCount - 1 )
 layer = B_Cu;
 
 if( !zone->IsOnLayer( PCB_LAYER_ID( layer ) ) )
 continue;
 
 KEEPOUT* keepout = new KEEPOUT( m_pcb->structure, keepout_type );
 m_pcb->structure->keepouts.push_back( keepout );
 
 PATH* mainPolygon = new PATH( keepout, T_polygon );
 keepout->SetShape( mainPolygon );
 
 mainPolygon->layer_id = m_layerIds[ m_kicadLayer2pcb[ layer ] ];
 
 // Handle the main outlines
 SHAPE_POLY_SET::ITERATOR iterator;
 bool is_first_point = true;
 wxPoint startpoint;
 
 for( iterator = zone->IterateWithHoles(); iterator; iterator++ )
 {
 wxPoint point( iterator->x, iterator->y );
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 mainPolygon->AppendPoint( mapPt( point ) );
 
 // this was the end of the main polygon
 if( iterator.IsEndContour() )
 {
 mainPolygon->AppendPoint( mapPt( startpoint ) );
 break;
 }
 }
 
 WINDOW* window = nullptr;
 PATH* cutout = nullptr;
 
 bool isStartContour = true;
 
 // handle the cutouts
 for( iterator++; iterator; iterator++ )
 {
 if( isStartContour )
 {
 is_first_point = true;
 window = new WINDOW( keepout );
 keepout->AddWindow( window );
 
 cutout = new PATH( window, T_polygon );
 window->SetShape( cutout );
 cutout->layer_id = m_layerIds[ m_kicadLayer2pcb[ zone->GetLayer() ] ];
 }
 
 isStartContour = iterator.IsEndContour();
 
 wxASSERT( window );
 wxASSERT( cutout );
 
 wxPoint point(iterator->x, iterator->y );
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 cutout->AppendPoint( mapPt(point) );
 
 // Close the polygon
 if( iterator.IsEndContour() )
 cutout->AppendPoint( mapPt( startpoint ) );
 }
 }
 }
 }
 
 //-----<build the images, components, and netlist>-----------------------
 {
 PIN_REF empty( m_pcb->network );
 std::string componentId;
 int highestNetCode = 0;
 NETINFO_LIST& netInfo = aBoard->GetNetInfo();
 
 // find the highest numbered netCode within the board.
 for( NETINFO_LIST::iterator i = netInfo.begin(); i != netInfo.end(); ++i )
 highestNetCode = std::max( highestNetCode, i->GetNetCode() );
 
 deleteNETs();
 
 // expand the net vector to highestNetCode+1, setting empty to NULL
 m_nets.resize( highestNetCode + 1, nullptr );
 
 for( unsigned i = 1 /* skip "No Net" at [0] */; i < m_nets.size(); ++i )
 m_nets[i] = new NET( m_pcb->network );
 
 for( NETINFO_LIST::iterator i = netInfo.begin(); i != netInfo.end(); ++i )
 {
 if( i->GetNetCode() > 0 )
 m_nets[i->GetNetCode()]->net_id = TO_UTF8( i->GetNetname() );
 }
 
 m_padstackset.clear();
 
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 IMAGE* image = makeIMAGE( aBoard, footprint );
 
 componentId = TO_UTF8( footprint->GetReference() );
 
 // Create a net list entry for all the actual pins in the current footprint.
 // Location of this code is critical because we fabricated some pin names to ensure
 // unique-ness within a footprint, and the life of this 'IMAGE* image' is not
 // necessarily long. The exported netlist will have some fabricated pin names in it.
 // If you don't like fabricated pin names, then make sure all pads within your
 // FOOTPRINTs are uniquely named!
 for( unsigned p = 0; p < image->pins.size(); ++p )
 {
 PIN* pin = &image->pins[p];
 int netcode = pin->kiNetCode;
 
 if( netcode > 0 )
 {
 NET* net = m_nets[netcode];
 
 net->pins.push_back( empty );
 
 PIN_REF& pin_ref = net->pins.back();
 
 pin_ref.component_id = componentId;
 pin_ref.pin_id = pin->pin_id;
 }
 }
 
 IMAGE* registered = m_pcb->library->LookupIMAGE( image );
 
 if( registered != image )
 {
 // If our new 'image' is not a unique IMAGE, delete it.
 // and use the registered one, known as 'image' after this.
 delete image;
 image = registered;
 }
 
 COMPONENT* comp = m_pcb->placement->LookupCOMPONENT( image->GetImageId() );
 PLACE* place = new PLACE( comp );
 
 comp->places.push_back( place );
 
 place->SetRotation( footprint->GetOrientationDegrees() );
 place->SetVertex( mapPt( footprint->GetPosition() ) );
 place->component_id = componentId;
 place->part_number = TO_UTF8( footprint->GetValue() );
 
 // footprint is flipped from bottom side, set side to T_back
 if( footprint->GetFlag() )
 {
 EDA_ANGLE angle = ANGLE_180 - footprint->GetOrientation();
 place->SetRotation( angle.Normalize().AsDegrees() );
 
 place->side = T_back;
 }
 }
 
 // copy the SPECCTRA_DB::padstackset to the LIBRARY. Since we are
 // removing, do not increment the iterator
 for( PADSTACKSET::iterator i = m_padstackset.begin(); i != m_padstackset.end();
 i = m_padstackset.begin() )
 {
 PADSTACKSET::auto_type ps = m_padstackset.release( i );
 PADSTACK* padstack = ps.release();
 
 m_pcb->library->AddPadstack( padstack );
 }
 
 // copy our SPECCTRA_DB::nets to the pcb->network
 for( unsigned n = 1; n < m_nets.size(); ++n )
 {
 NET* net = m_nets[n];
 
 if( net->pins.size() )
 {
 // give ownership to pcb->network
 m_pcb->network->nets.push_back( net );
 m_nets[n] = 0;
 }
 }
 }
 
 //-----< output vias used in netclasses >-----------------------------------
 {
 // Assume the netclass vias are all the same kind of thru, blind, or buried vias.
 // This is in lieu of either having each netclass via have its own layer pair in
 // the netclass dialog, or such control in the specctra export dialog.
 
 m_top_via_layer = 0; // first specctra cu layer is number zero.
 m_bot_via_layer = aBoard->GetCopperLayerCount()-1;
 
 // Add the via from the Default netclass first. The via container
 // in pcb->library preserves the sequence of addition.
 
 PADSTACK* via = makeVia( netSettings->m_DefaultNetClass->GetViaDiameter(),
 netSettings->m_DefaultNetClass->GetViaDrill(),
 m_top_via_layer, m_bot_via_layer );
 
 // we AppendVia() this first one, there is no way it can be a duplicate,
 // the pcb->library via container is empty at this point. After this,
 // we'll have to use LookupVia().
 wxASSERT( m_pcb->library->vias.size() == 0 );
 m_pcb->library->AppendVia( via );
 
 // set the "spare via" index at the start of the
 // pcb->library->spareViaIndex = pcb->library->vias.size();
 
 // output the non-Default netclass vias
 for( const auto& [ name, netclass ] : netSettings->m_NetClasses )
 {
 via = makeVia( netclass->GetViaDiameter(), netclass->GetViaDrill(),
 m_top_via_layer, m_bot_via_layer );
 
 // maybe add 'via' to the library, but only if unique.
 PADSTACK* registered = m_pcb->library->LookupVia( via );
 
 if( registered != via )
 delete via;
 }
 }
 
 //-----<create the wires from tracks>-----------------------------------
 {
 // export all of them for now, later we'll decide what controls we need on this.
 std::string netname;
 WIRING* wiring = m_pcb->wiring;
 PATH* path = 0;
 
 int old_netcode = -1;
 int old_width = -1;
 int old_layer = UNDEFINED_LAYER;
 
 for( PCB_TRACK* track : aBoard->Tracks() )
 {
 if( !track->IsType( { PCB_TRACE_T, PCB_ARC_T } ) )
 continue;
 
 int netcode = track->GetNetCode();
 
 if( netcode == 0 )
 continue;
 
 if( old_netcode != netcode
 || old_width != track->GetWidth()
 || old_layer != track->GetLayer()
 || ( path && path->points.back() != mapPt( track->GetStart() ) ) )
 {
 old_width = track->GetWidth();
 old_layer = track->GetLayer();
 
 if( old_netcode != netcode )
 {
 old_netcode = netcode;
 NETINFO_ITEM* net = aBoard->FindNet( netcode );
 wxASSERT( net );
 netname = TO_UTF8( net->GetNetname() );
 }
 
 WIRE* wire = new WIRE( wiring );
 
 wiring->wires.push_back( wire );
 wire->net_id = netname;
 
 if( track->IsLocked() )
 wire->wire_type = T_fix; // tracks with fix property are not returned in .ses files
 else
 wire->wire_type = T_route; // could be T_protect
 
 int kiLayer = track->GetLayer();
 int pcbLayer = m_kicadLayer2pcb[kiLayer];
 
 path = new PATH( wire );
 wire->SetShape( path );
 path->layer_id = m_layerIds[pcbLayer];
 path->aperture_width = scale( old_width );
 path->AppendPoint( mapPt( track->GetStart() ) );
 }
 
 if( path ) // Should not occur
 path->AppendPoint( mapPt( track->GetEnd() ) );
 }
 }
 
 //-----<export the existing real BOARD instantiated vias>-----------------
 {
 // Export all vias, once per unique size and drill diameter combo.
 for( PCB_TRACK* track : aBoard->Tracks() )
 {
 if( track->Type() != PCB_VIA_T )
 continue;
 
 PCB_VIA* via = static_cast<PCB_VIA*>( track );
 int netcode = via->GetNetCode();
 
 if( netcode == 0 )
 continue;
 
 PADSTACK* padstack = makeVia( via );
 PADSTACK* registered = m_pcb->library->LookupVia( padstack );
 
 // if the one looked up is not our padstack, then delete our padstack
 // since it was a duplicate of one already registered.
 if( padstack != registered )
 delete padstack;
 
 WIRE_VIA* dsnVia = new WIRE_VIA( m_pcb->wiring );
 
 m_pcb->wiring->wire_vias.push_back( dsnVia );
 
 dsnVia->padstack_id = registered->padstack_id;
 dsnVia->vertexes.push_back( mapPt( via->GetPosition() ) );
 
 NETINFO_ITEM* net = aBoard->FindNet( netcode );
 wxASSERT( net );
 
 dsnVia->net_id = TO_UTF8( net->GetNetname() );
 
 if( via->IsLocked() )
 dsnVia->via_type = T_fix; // vias with fix property are not returned in .ses files
 else
 dsnVia->via_type = T_route; // could be T_protect
 }
 }
 
 //-----<via_descriptor>-------------------------------------------------
 {
 // The pcb->library will output <padstack_descriptors> which is a combined list of part
 // padstacks and via padstacks. specctra dsn uses the <via_descriptors> to say which of
 // those padstacks are vias.
 
 // Output the vias in the padstack list here, by name only. This must be done after
 // exporting existing vias as WIRE_VIAs.
 VIA* vias = m_pcb->structure->via;
 
 for( unsigned viaNdx = 0; viaNdx < m_pcb->library->vias.size(); ++viaNdx )
 vias->AppendVia( m_pcb->library->vias[viaNdx].padstack_id.c_str() );
 }
 
 //-----<output NETCLASSs>----------------------------------------------------
 
 exportNETCLASS( netSettings->m_DefaultNetClass, aBoard );
 
 for( const auto& [ name, netclass ] : netSettings->m_NetClasses )
 exportNETCLASS( netclass, aBoard );
}

References _, DSN::LIBRARY::AddPadstack(), DSN::KEEPOUT::AddWindow(), PNS::angle(), ANGLE_180, DSN::PATH::AppendPoint(), DSN::VIA::AppendVia(), DSN::LIBRARY::AppendVia(), B_Cu, NETINFO_LIST::begin(), buildLayerMaps(), DSN::PLACE::component_id, DSN::PIN_REF::component_id, deleteNETs(), empty(), NETINFO_LIST::end(), exportNETCLASS(), fillBOUNDARY(), BOARD::FindNet(), BOARD::Footprints(), Format(), BOARD::GetCopperLayerCount(), BOARD::GetDesignSettings(), BOARD::GetLayerType(), BOARD::GetNetInfo(), NETINFO_ITEM::GetNetname(), image, IsCopperLayer(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::IsEndContour(), DSN::STRUCTURE::keepouts, DSN::PATH::layer_id, DSN::LAYER::layer_type, DSN::STRUCTURE::layers, DSN::PCB::library, DSN::PLACEMENT::LookupCOMPONENT(), DSN::LIBRARY::LookupIMAGE(), DSN::LIBRARY::LookupVia(), LT_JUMPER, LT_MIXED, LT_POWER, LT_SIGNAL, m_bot_via_layer, m_kicadLayer2pcb, m_layerIds, m_nets, BOARD_DESIGN_SETTINGS::m_NetSettings, m_padstackset, m_pcb, m_pcbLayer2kicad, m_top_via_layer, makeIMAGE(), MakePCB(), makeVia(), DSN::mapPt(), name, DSN::KEEPOUT::name, DSN::LAYER::name, DSN::NET::net_id, DSN::WIRE::net_id, DSN::WIRE_VIA::net_id, DSN::NETWORK::nets, DSN::PCB::network, DSN::WIRE_VIA::padstack_id, DSN::PCB::parser, DSN::PLACE::part_number, path, PCB_VIA_T, pin, DSN::PIN_REF::pin_id, DSN::NET::pins, DSN::PCB::placement, DSN::COMPONENT::places, DSN::STRUCTURE::planes, DSN::LAYER::properties, registered, DSN::PCB::resolution, DSN::RULE::rules, DSN::STRUCTURE::rules, safetyMargin, DSN::scale(), DSN::STRUCTURE::SetBOUNDARY(), DSN::PLACE::SetRotation(), DSN::WINDOW::SetShape(), DSN::KEEPOUT::SetShape(), DSN::WIRE::SetShape(), DSN::PLACE::SetVertex(), DSN::PLACE::side, DSN::PARSER::space_in_quoted_tokens, DSN::PCB::structure, THROW_IO_ERROR, TO_UTF8, BOARD::Tracks(), UNDEFINED_LAYER, DSN::PCB::unit, DSN::UNIT_RES::units, DSN::UNIT_RES::value, DSN::WIRE_VIA::vertexes, via, DSN::STRUCTURE::via, DSN::WIRE_VIA::via_type, DSN::LIBRARY::vias, DSN::WIRE::wire_type, DSN::WIRING::wire_vias, DSN::WIRING::wires, DSN::PCB::wiring, and BOARD::Zones().

Referenced by ExportBoardToSpecctraFile().

FromSESSION()

void DSN::SPECCTRA_DB::FromSESSION

(

BOARD *

aBoard

)

Add the entire #SESSION info to a BOARD but does not write it out.

The BOARD given to this function will have all its tracks and via's replaced, and all its components are subject to being moved.

Parameters

aBoard

The BOARD to merge the #SESSION information into.

Definition at line 337 of file specctra_import.cpp.

{
 m_sessionBoard = aBoard; // not owned here
 
 if( !m_session )
 THROW_IO_ERROR( _("Session file is missing the \"session\" section") );
 
 if( !m_session->route )
 THROW_IO_ERROR( _("Session file is missing the \"routes\" section") );
 
 if( !m_session->route->library )
 THROW_IO_ERROR( _("Session file is missing the \"library_out\" section") );
 
 // delete the old tracks and vias but save locked tracks/vias; they will be re-added later
 std::vector<PCB_TRACK*> locked;
 
 while( !aBoard->Tracks().empty() )
 {
 PCB_TRACK* track = aBoard->Tracks().back();
 aBoard->Tracks().pop_back();
 
 if( track->IsLocked() )
 locked.push_back( track );
 else
 delete track;
 }
 
 aBoard->DeleteMARKERs();
 
 buildLayerMaps( aBoard );
 
 // Add locked tracks: because they are exported as Fix tracks, they are not
 // in .ses file.
 for( PCB_TRACK* track: locked )
 aBoard->Add( track );
 
 if( m_session->placement )
 {
 // Walk the PLACEMENT object's COMPONENTs list, and for each PLACE within
 // each COMPONENT, reposition and re-orient each component and put on
 // correct side of the board.
 COMPONENTS& components = m_session->placement->components;
 
 for( COMPONENTS::iterator comp=components.begin(); comp!=components.end(); ++comp )
 {
 PLACES& places = comp->places;
 for( unsigned i=0; i<places.size(); ++i )
 {
 PLACE* place = &places[i]; // '&' even though places[] holds a pointer!
 
 wxString reference = FROM_UTF8( place->component_id.c_str() );
 FOOTPRINT* footprint = aBoard->FindFootprintByReference( reference );
 
 if( !footprint )
 {
 THROW_IO_ERROR( wxString::Format( _( "Reference '%s' not found." ),
 reference ) );
 }
 
 if( !place->hasVertex )
 continue;
 
 UNIT_RES* resolution = place->GetUnits();
 wxASSERT( resolution );
 
 wxPoint newPos = mapPt( place->vertex, resolution );
 footprint->SetPosition( newPos );
 
 if( place->side == T_front )
 {
 // convert from degrees to tenths of degrees used in KiCad.
 EDA_ANGLE orientation( place->rotation, DEGREES_T );
 
 if( footprint->GetLayer() != F_Cu )
 {
 // footprint is on copper layer (back)
 footprint->Flip( footprint->GetPosition(), false );
 }
 
 footprint->SetOrientation( orientation );
 }
 else if( place->side == T_back )
 {
 EDA_ANGLE orientation( place->rotation + 180.0, DEGREES_T );
 
 if( footprint->GetLayer() != B_Cu )
 {
 // footprint is on component layer (front)
 footprint->Flip( footprint->GetPosition(), false );
 }
 
 footprint->SetOrientation( orientation );
 }
 else
 {
 // as I write this, the PARSER *is* catching this, so we should never see below:
 wxFAIL_MSG( wxT("DSN::PARSER did not catch an illegal side := 'back|front'") );
 }
 }
 }
 }
 
 m_routeResolution = m_session->route->GetUnits();
 
 // Walk the NET_OUTs and create tracks and vias anew.
 NET_OUTS& net_outs = m_session->route->net_outs;
 for( NET_OUTS::iterator net = net_outs.begin(); net!=net_outs.end(); ++net )
 {
 int netoutCode = 0;
 
 // page 143 of spec says wire's net_id is optional
 if( net->net_id.size() )
 {
 wxString netName = FROM_UTF8( net->net_id.c_str() );
 NETINFO_ITEM* netinfo = aBoard->FindNet( netName );
 
 if( netinfo )
 netoutCode = netinfo->GetNetCode();
 }
 
 WIRES& wires = net->wires;
 for( unsigned i = 0; i<wires.size(); ++i )
 {
 WIRE* wire = &wires[i];
 DSN_T shape = wire->shape->Type();
 
 if( shape != T_path )
 {
 /*
 * shape == T_polygon is expected from freerouter if you have a zone on a non-
 * "power" type layer, i.e. a T_signal layer and the design does a round-trip
 * back in as session here. We kept our own zones in the BOARD, so ignore this
 * so called 'wire'.
 
 wxString netId = FROM_UTF8( wire->net_id.c_str() );
 THROW_IO_ERROR( wxString::Format( _( "Unsupported wire shape: '%s' for net: '%s'" ),
 DLEX::GetTokenString(shape).GetData(),
 netId.GetData() ) );
 */
 }
 else
 {
 PATH* path = (PATH*) wire->shape;
 
 for( unsigned pt=0; pt < path->points.size()-1; ++pt )
 {
 PCB_TRACK* track = makeTRACK( wire, path, pt, netoutCode );
 aBoard->Add( track );
 }
 }
 }
 
 WIRE_VIAS& wire_vias = net->wire_vias;
 LIBRARY& library = *m_session->route->library;
 
 for( unsigned i=0; i<wire_vias.size(); ++i )
 {
 int netCode = 0;
 
 // page 144 of spec says wire_via's net_id is optional
 if( net->net_id.size() )
 {
 wxString netName = FROM_UTF8( net->net_id.c_str() );
 NETINFO_ITEM* netvia = aBoard->FindNet( netName );
 
 if( netvia )
 netCode = netvia->GetNetCode();
 }
 
 WIRE_VIA* wire_via = &wire_vias[i];
 
 // example: (via Via_15:8_mil 149000 -71000 )
 
 PADSTACK* padstack = library.FindPADSTACK( wire_via->GetPadstackId() );
 if( !padstack )
 {
 // Dick Feb 29, 2008:
 // Freerouter has a bug where it will not round trip all vias. Vias which have
 // a (use_via) element will be round tripped. Vias which do not, don't come back
 // in in the session library, even though they may be actually used in the
 // pre-routed, protected wire_vias. So until that is fixed, create the padstack
 // from its name as a work around.
 wxString psid( FROM_UTF8( wire_via->GetPadstackId().c_str() ) );
 
 THROW_IO_ERROR( wxString::Format( _( "A wire_via refers to missing padstack '%s'." ),
 psid ) );
 }
 
 std::shared_ptr<NET_SETTINGS>& netSettings = aBoard->GetDesignSettings().m_NetSettings;
 
 int via_drill_default = netSettings->m_DefaultNetClass->GetViaDrill();
 
 for( unsigned v = 0; v < wire_via->vertexes.size(); ++v )
 {
 PCB_VIA* via = makeVIA( wire_via, padstack, wire_via->vertexes[v], netCode,
 via_drill_default );
 aBoard->Add( via );
 }
 }
 }
}

References _, BOARD::Add(), B_Cu, buildLayerMaps(), DSN::PLACE::component_id, DSN::PLACEMENT::components, DEGREES_T, BOARD::DeleteMARKERs(), F_Cu, BOARD::FindFootprintByReference(), BOARD::FindNet(), FOOTPRINT::Flip(), Format(), FROM_UTF8(), BOARD::GetDesignSettings(), BOARD_ITEM::GetLayer(), NETINFO_ITEM::GetNetCode(), DSN::WIRE_VIA::GetPadstackId(), FOOTPRINT::GetPosition(), DSN::ELEM::GetUnits(), DSN::ROUTE::GetUnits(), DSN::PLACE::hasVertex, BOARD_ITEM::IsLocked(), library, DSN::ROUTE::library, locked, BOARD_DESIGN_SETTINGS::m_NetSettings, m_routeResolution, m_session, m_sessionBoard, makeTRACK(), makeVIA(), DSN::mapPt(), DSN::ROUTE::net_outs, path, DSN::SESSION::placement, DSN::PLACE::rotation, DSN::SESSION::route, FOOTPRINT::SetOrientation(), FOOTPRINT::SetPosition(), DSN::WIRE::shape, DSN::PLACE::side, THROW_IO_ERROR, BOARD::Tracks(), DSN::ELEM::Type(), DSN::PLACE::vertex, DSN::WIRE_VIA::vertexes, and via.

Referenced by PCB_EDIT_FRAME::ImportSpecctraSession().

GetPCB()

PCB * DSN::SPECCTRA_DB::GetPCB ( )

inline

Definition at line 3694 of file specctra.h.

{ return m_pcb; }

References m_pcb.

Referenced by main().

GetSESSION()

SESSION * DSN::SPECCTRA_DB::GetSESSION ( )

inline

Definition at line 3705 of file specctra.h.

{ return m_session; }

References m_session.

Referenced by main().

LoadPCB()

void DSN::SPECCTRA_DB::LoadPCB

(

const wxString &

aFilename

)

A recursive descent parser for a SPECCTRA DSN "design" file.

A design file is nearly a full description of a PCB (seems to be missing only the silkscreen stuff).

Parameters

aFilename

The name of the dsn file to load.

Exceptions

IO_ERROR

if there is a lexer or parser error.

Definition at line 258 of file specctra.cpp.

{
 FILE_LINE_READER curr_reader( aFilename );
 
 PushReader( &curr_reader );
 
 if( NextTok() != T_LEFT )
 Expecting( T_LEFT );
 
 if( NextTok() != T_pcb )
 Expecting( T_pcb );
 
 SetPCB( new PCB() );
 
 doPCB( m_pcb );
 PopReader();
}

References doPCB(), m_pcb, and SetPCB().

LoadSESSION()

void DSN::SPECCTRA_DB::LoadSESSION

(

const wxString &

aFilename

)

A recursive descent parser for a SPECCTRA DSN "session" file.

A session file is a file that is fed back from the router to the layout tool (Pcbnew) and should be used to update a BOARD object with the new tracks, vias, and component locations.

Parameters

aFilename

The name of the dsn file to load.

Exceptions

IO_ERROR

if there is a lexer or parser error.

Definition at line 277 of file specctra.cpp.

{
 FILE_LINE_READER curr_reader( aFilename );
 
 PushReader( &curr_reader );
 
 if( NextTok() != T_LEFT )
 Expecting( T_LEFT );
 
 if( NextTok() != T_session )
 Expecting( T_session );
 
 SetSESSION( new SESSION() );
 
 doSESSION( m_session );
 
 PopReader();
}

References doSESSION(), m_session, and SetSESSION().

Referenced by PCB_EDIT_FRAME::ImportSpecctraSession(), and main().

makeIMAGE()

IMAGE * DSN::SPECCTRA_DB::makeIMAGE ( BOARD *  aBoard, FOOTPRINT *  aFootprint  )

private

Allocates an I::MAGE on the heap and creates all the PINs according to the PADs in the FOOTPRINT.

Parameters

aBoard	The owner of the FOOTPRINT.
aFootprint	The FOOTPRINT from which to build the IMAGE.

Returns

not tested for duplication yet.

Definition at line 599 of file specctra_export.cpp.

{
 PINMAP pinmap;
 wxString padNumber;
 
 PCB_TYPE_COLLECTOR fpItems;
 
 // get all the FOOTPRINT's pads.
 fpItems.Collect( aFootprint, { PCB_PAD_T } );
 
 IMAGE* image = new IMAGE( 0 );
 
 image->image_id = aFootprint->GetFPID().Format().c_str();
 
 // from the pads, and make an IMAGE using collated padstacks.
 for( int p = 0; p < fpItems.GetCount(); ++p )
 {
 PAD* pad = (PAD*) fpItems[p];
 
 // see if this pad is a through hole with no copper on its perimeter
 if( isRoundKeepout( pad ) )
 {
 double diameter = scale( pad->GetDrillSize().x );
 POINT vertex = mapPt( pad->GetPos0() );
 
 int layerCount = aBoard->GetCopperLayerCount();
 
 for( int layer=0; layer<layerCount; ++layer )
 {
 KEEPOUT* keepout = new KEEPOUT( image, T_keepout );
 
 image->keepouts.push_back( keepout );
 
 CIRCLE* circle = new CIRCLE( keepout );
 
 keepout->SetShape( circle );
 
 circle->SetDiameter( diameter );
 circle->SetVertex( vertex );
 circle->SetLayerId( m_layerIds[layer].c_str() );
 }
 }
 else // else if() could there be a square keepout here?
 {
 // Pads not on copper layers (i.e. only on tech layers) are ignored
 // because they create invalid pads in .dsn file for freeroute
 LSET mask_copper_layers = pad->GetLayerSet() & LSET::AllCuMask();
 
 if( !mask_copper_layers.any() )
 continue;
 
 PADSTACK* padstack = makePADSTACK( aBoard, pad );
 PADSTACKSET::iterator iter = m_padstackset.find( *padstack );
 
 if( iter != m_padstackset.end() )
 {
 // padstack is a duplicate, delete it and use the original
 delete padstack;
 padstack = (PADSTACK*) *iter.base(); // folklore, be careful here
 }
 else
 {
 m_padstackset.insert( padstack );
 }
 
 PIN* pin = new PIN( image );
 
 padNumber = pad->GetNumber();
 pin->pin_id = TO_UTF8( padNumber );
 
 if( padNumber != wxEmptyString && pinmap.find( padNumber ) == pinmap.end() )
 {
 pinmap[ padNumber ] = 0;
 }
 else // pad name is a duplicate within this footprint
 {
 char buf[32];
 int duplicates = ++pinmap[ padNumber ];
 
 sprintf( buf, "@%d", duplicates );
 
 pin->pin_id += buf; // append "@1" or "@2", etc. to pin name
 }
 
 pin->kiNetCode = pad->GetNetCode();
 
 image->pins.push_back( pin );
 
 pin->padstack_id = padstack->padstack_id;
 
 EDA_ANGLE angle = pad->GetOrientation() - aFootprint->GetOrientation();
 pin->SetRotation( angle.Normalize().AsDegrees() );
 
 wxPoint pos( pad->GetPos0() );
 
 pin->SetVertex( mapPt( pos ) );
 }
 }
 
 // get all the FOOTPRINT's FP_SHAPEs and convert those to DSN outlines.
 fpItems.Collect( aFootprint, { PCB_FP_SHAPE_T } );
 
 for( int i = 0; i < fpItems.GetCount(); ++i )
 {
 FP_SHAPE* graphic = (FP_SHAPE*) fpItems[i];
 SHAPE* outline;
 PATH* path;
 
 switch( graphic->GetShape() )
 {
 case SHAPE_T::SEGMENT:
 outline = new SHAPE( image, T_outline );
 
 image->Append( outline );
 path = new PATH( outline );
 
 outline->SetShape( path );
 path->SetAperture( scale( graphic->GetWidth() ) );
 path->SetLayerId( "signal" );
 path->AppendPoint( mapPt( graphic->GetStart0() ) );
 path->AppendPoint( mapPt( graphic->GetEnd0() ) );
 break;
 
 case SHAPE_T::CIRCLE:
 {
 // this is best done by 4 QARC's but freerouter does not yet support QARCs.
 // for now, support by using line segments.
 outline = new SHAPE( image, T_outline );
 image->Append( outline );
 
 path = new PATH( outline );
 
 outline->SetShape( path );
 path->SetAperture( scale( graphic->GetWidth() ) );
 path->SetLayerId( "signal" );
 
 double radius = graphic->GetRadius();
 VECTOR2I circle_centre = graphic->GetStart0();
 
 SHAPE_LINE_CHAIN polyline;
 ConvertArcToPolyline( polyline, VECTOR2I( circle_centre ), radius, ANGLE_0, ANGLE_360,
 ARC_HIGH_DEF, ERROR_INSIDE );
 
 for( int ii = 0; ii < polyline.PointCount(); ++ii )
 {
 VECTOR2I corner( polyline.CPoint( ii ).x, polyline.CPoint( ii ).y );
 path->AppendPoint( mapPt( corner ) );
 }
 
 break;
 }
 
 case SHAPE_T::RECT:
 {
 outline = new SHAPE( image, T_outline );
 
 image->Append( outline );
 path = new PATH( outline );
 
 outline->SetShape( path );
 path->SetAperture( scale( graphic->GetWidth() ) );
 path->SetLayerId( "signal" );
 VECTOR2I corner = graphic->GetStart0();
 path->AppendPoint( mapPt( corner ) );
 
 corner.x = graphic->GetEnd0().x;
 path->AppendPoint( mapPt( corner ) );
 
 corner.y = graphic->GetEnd0().y;
 path->AppendPoint( mapPt( corner ) );
 
 corner.x = graphic->GetStart0().x;
 path->AppendPoint( mapPt( corner ) );
 break;
 }
 
 case SHAPE_T::ARC:
 {
 // this is best done by QARC's but freerouter does not yet support QARCs.
 // for now, support by using line segments.
 // So we use a polygon (PATH) to create a approximate arc shape
 outline = new SHAPE( image, T_outline );
 
 image->Append( outline );
 path = new PATH( outline );
 
 outline->SetShape( path );
 path->SetAperture( 0 );//scale( graphic->GetWidth() ) );
 path->SetLayerId( "signal" );
 
 VECTOR2I arc_centre = graphic->GetCenter0();
 double radius = graphic->GetRadius() + graphic->GetWidth()/2;
 EDA_ANGLE arcAngle = graphic->GetArcAngle();
 
 VECTOR2I startRadial = graphic->GetStart() - graphic->GetCenter();
 EDA_ANGLE arcStart( startRadial );
 
 arcStart.Normalize();
 
 // For some obscure reason, FreeRouter does not show the same polygonal
 // shape for polygons CW and CCW. So used only the order of corners
 // giving the best look.
 if( arcAngle < ANGLE_0 )
 {
 VECTOR2I endRadial = graphic->GetEnd() - graphic->GetCenter();
 arcStart = EDA_ANGLE( endRadial );
 arcStart.Normalize();
 
 arcAngle = -arcAngle;
 }
 
 SHAPE_LINE_CHAIN polyline;
  ConvertArcToPolyline( polyline, VECTOR2I( arc_centre ), radius, arcStart, arcAngle,
 ARC_HIGH_DEF, ERROR_INSIDE );
 
 SHAPE_POLY_SET polyBuffer;
 polyBuffer.AddOutline( polyline );
 
 radius -= graphic->GetWidth();
 
 if( radius > 0 )
 {
 polyline.Clear();
 ConvertArcToPolyline( polyline, VECTOR2I( arc_centre ), radius, arcStart, arcAngle,
 ARC_HIGH_DEF, ERROR_INSIDE );
 
 // Add points in reverse order, to create a closed polygon
 for( int ii = polyline.PointCount() - 1; ii >= 0; --ii )
 polyBuffer.Append( polyline.CPoint( ii ) );
 }
 
 // ensure the polygon is closed
 polyBuffer.Append( polyBuffer.Outline( 0 ).CPoint( 0 ) );
 
 VECTOR2I move = graphic->GetCenter() - arc_centre;
 
 TransformCircleToPolygon( polyBuffer, graphic->GetStart() - move,
 graphic->GetWidth() / 2, ARC_HIGH_DEF, ERROR_INSIDE );
 
 TransformCircleToPolygon( polyBuffer, graphic->GetEnd() - move,
 graphic->GetWidth() / 2, ARC_HIGH_DEF, ERROR_INSIDE );
 
 polyBuffer.Simplify( SHAPE_POLY_SET::PM_FAST );
 SHAPE_LINE_CHAIN& poly = polyBuffer.Outline( 0 );
 
 for( int ii = 0; ii < poly.PointCount(); ++ii )
 {
 VECTOR2I corner( poly.CPoint( ii ).x, poly.CPoint( ii ).y );
 path->AppendPoint( mapPt( corner ) );
 }
 
 break;
 }
 
 default:
 continue;
 }
 }
 
 for( FP_ZONE* zone : aFootprint->Zones() )
 {
 if( !zone->GetIsRuleArea() )
 continue;
 
 // IMAGE object coordinates are relative to the IMAGE not absolute board coordinates.
 ZONE untransformedZone( *zone );
 
 EDA_ANGLE angle = -aFootprint->GetOrientation();
 angle.Normalize();
 untransformedZone.Rotate( aFootprint->GetPosition(), angle );
 
 // keepout areas have a type. types are
 // T_place_keepout, T_via_keepout, T_wire_keepout,
 // T_bend_keepout, T_elongate_keepout, T_keepout.
 // Pcbnew knows only T_keepout, T_via_keepout and T_wire_keepout
 DSN_T keepout_type;
 
 if( zone->GetDoNotAllowVias() && zone->GetDoNotAllowTracks() )
 keepout_type = T_keepout;
 else if( zone->GetDoNotAllowVias() )
  keepout_type = T_via_keepout;
 else if( zone->GetDoNotAllowTracks() )
 keepout_type = T_wire_keepout;
 else
 keepout_type = T_keepout;
 
 // Now, build keepout polygon on each copper layer where the zone
 // keepout is living (keepout zones can live on many copper layers)
 const int copperCount = aBoard->GetCopperLayerCount();
 
 for( int layer = 0; layer < copperCount; layer++ )
 {
 if( layer == copperCount-1 )
 layer = B_Cu;
 
 if( !zone->IsOnLayer( PCB_LAYER_ID( layer ) ) )
 continue;
 
 KEEPOUT* keepout = new KEEPOUT( m_pcb->structure, keepout_type );
 image->keepouts.push_back( keepout );
 
 PATH* mainPolygon = new PATH( keepout, T_polygon );
 keepout->SetShape( mainPolygon );
 
 mainPolygon->layer_id = m_layerIds[ m_kicadLayer2pcb[ layer ] ];
 
 // Handle the main outlines
 SHAPE_POLY_SET::ITERATOR iterator;
 bool is_first_point = true;
 VECTOR2I startpoint;
 
 for( iterator = untransformedZone.IterateWithHoles(); iterator; iterator++ )
 {
 VECTOR2I point( iterator->x, iterator->y );
 
 point -= aFootprint->GetPosition();
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 mainPolygon->AppendPoint( mapPt( point ) );
 
 // this was the end of the main polygon
 if( iterator.IsEndContour() )
 {
 mainPolygon->AppendPoint( mapPt( startpoint ) );
 break;
 }
 }
 
 WINDOW* window = nullptr;
 PATH* cutout = nullptr;
 bool isStartContour = true;
 
 // handle the cutouts
 for( iterator++; iterator; iterator++ )
 {
 if( isStartContour )
 {
 is_first_point = true;
 window = new WINDOW( keepout );
 keepout->AddWindow( window );
 
 cutout = new PATH( window, T_polygon );
 
 window->SetShape( cutout );
 
 cutout->layer_id = m_layerIds[ m_kicadLayer2pcb[ zone->GetLayer() ] ];
 }
 
 isStartContour = iterator.IsEndContour();
 
 wxASSERT( window );
 wxASSERT( cutout );
 
 VECTOR2I point( iterator->x, iterator->y );
 
 point -= aFootprint->GetPosition();
 
 if( is_first_point )
 {
 startpoint = point;
 is_first_point = false;
 }
 
 cutout->AppendPoint( mapPt( point ) );
 
 // Close the polygon
 if( iterator.IsEndContour() )
 cutout->AppendPoint( mapPt( startpoint ) );
 }
 }
 }
 
 return image;
}

References SHAPE_POLY_SET::AddOutline(), DSN::KEEPOUT::AddWindow(), LSET::AllCuMask(), PNS::angle(), ANGLE_0, ANGLE_360, SHAPE_POLY_SET::Append(), DSN::PATH::AppendPoint(), ARC, ARC_HIGH_DEF, B_Cu, UTF8::c_str(), CIRCLE, SHAPE_LINE_CHAIN::Clear(), PCB_TYPE_COLLECTOR::Collect(), ConvertArcToPolyline(), SHAPE_LINE_CHAIN::CPoint(), ERROR_INSIDE, LIB_ID::Format(), EDA_SHAPE::GetArcAngle(), PCB_SHAPE::GetCenter(), FP_SHAPE::GetCenter0(), BOARD::GetCopperLayerCount(), COLLECTOR::GetCount(), EDA_SHAPE::GetEnd(), FP_SHAPE::GetEnd0(), FOOTPRINT::GetFPID(), FOOTPRINT::GetOrientation(), FOOTPRINT::GetPosition(), EDA_SHAPE::GetRadius(), EDA_SHAPE::GetShape(), EDA_SHAPE::GetStart(), FP_SHAPE::GetStart0(), EDA_SHAPE::GetWidth(), image, SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::IsEndContour(), DSN::isRoundKeepout(), ZONE::IterateWithHoles(), DSN::PATH::layer_id, m_kicadLayer2pcb, m_layerIds, m_padstackset, m_pcb, makePADSTACK(), DSN::mapPt(), move, EDA_ANGLE::Normalize(), SHAPE_POLY_SET::Outline(), pad, DSN::PADSTACK::padstack_id, path, PCB_FP_SHAPE_T, PCB_PAD_T, pin, SHAPE_POLY_SET::PM_FAST, SHAPE_LINE_CHAIN::PointCount(), RECT, ZONE::Rotate(), DSN::scale(), SEGMENT, DSN::CIRCLE::SetDiameter(), DSN::CIRCLE::SetLayerId(), DSN::WINDOW::SetShape(), DSN::KEEPOUT::SetShape(), DSN::CIRCLE::SetVertex(), SHAPE_POLY_SET::Simplify(), DSN::PCB::structure, TO_UTF8, TransformCircleToPolygon(), VECTOR2< T >::x, VECTOR2< T >::y, and FOOTPRINT::Zones().

Referenced by FromBOARD().

makePADSTACK()

PADSTACK * DSN::SPECCTRA_DB::makePADSTACK ( BOARD *  aBoard, PAD *  aPad  )

private

Create a #PADSTACK which matches the given pad.

Note

Only pads which do not satisfy the function isKeepout() should be passed to this function.

Parameters

aBoard	The owner of the PAD's footprint.
aPad	The PAD which needs to be made into a PADSTACK.

Returns

The created padstack, including its padstack_id.

Definition at line 238 of file specctra_export.cpp.

{
 char name[256]; // padstack name builder
 std::string uniqifier;
 
 // caller must do these checks before calling here.
 wxASSERT( !isRoundKeepout( aPad ) );
 
 PADSTACK* padstack = new PADSTACK();
 
 int reportedLayers = 0; // how many in reported padstack
 const char* layerName[MAX_CU_LAYERS];
 
 uniqifier = '[';
 
 static const LSET all_cu = LSET::AllCuMask();
 
 bool onAllCopperLayers = ( (aPad->GetLayerSet() & all_cu) == all_cu );
 
 if( onAllCopperLayers )
 uniqifier += 'A'; // A for all layers
 
 const int copperCount = aBoard->GetCopperLayerCount();
 
 for( int layer=0; layer<copperCount; ++layer )
 {
 PCB_LAYER_ID kilayer = m_pcbLayer2kicad[layer];
 
 if( onAllCopperLayers || aPad->IsOnLayer( kilayer ) )
 {
 layerName[reportedLayers++] = m_layerIds[layer].c_str();
 
 if( !onAllCopperLayers )
 {
 if( layer == 0 )
 uniqifier += 'T';
 else if( layer == copperCount - 1 )
 uniqifier += 'B';
 else
 uniqifier += char('0' + layer); // layer index char
 }
 }
 }
 
 uniqifier += ']';
 
 POINT dsnOffset;
 
 if( aPad->GetOffset().x || aPad->GetOffset().y )
 {
 char offsetTxt[64];
 
 VECTOR2I offset( aPad->GetOffset().x, aPad->GetOffset().y );
 
 dsnOffset = mapPt( offset );
 
 // using () would cause padstack name to be quoted, and {} locks freerouter, so use [].
 sprintf( offsetTxt, "[%.6g,%.6g]", dsnOffset.x, dsnOffset.y );
 
 uniqifier += offsetTxt;
 }
 
 switch( aPad->GetShape() )
 {
 case PAD_SHAPE::CIRCLE:
 {
 double diameter = scale( aPad->GetSize().x );
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
 SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 CIRCLE* circle = new CIRCLE( shape );
 
 shape->SetShape( circle );
 
 circle->SetLayerId( layerName[ndx] );
 circle->SetDiameter( diameter );
 circle->SetVertex( dsnOffset );
 }
 
 snprintf( name, sizeof(name), "Round%sPad_%.6g_um",
 uniqifier.c_str(), IU2um( aPad->GetSize().x ) );
 
 name[ sizeof(name) - 1 ] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 
 case PAD_SHAPE::RECT:
 {
 double dx = scale( aPad->GetSize().x ) / 2.0;
 double dy = scale( aPad->GetSize().y ) / 2.0;
 
 POINT lowerLeft( -dx, -dy );
 POINT upperRight( dx, dy );
 
 lowerLeft += dsnOffset;
 upperRight += dsnOffset;
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
 SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 RECTANGLE* rect = new RECTANGLE( shape );
 
 shape->SetShape( rect );
 
 rect->SetLayerId( layerName[ndx] );
 rect->SetCorners( lowerLeft, upperRight );
 }
 
 snprintf( name, sizeof( name ), "Rect%sPad_%.6gx%.6g_um", uniqifier.c_str(),
 IU2um( aPad->GetSize().x ), IU2um( aPad->GetSize().y ) );
 
 name[sizeof( name ) - 1] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 
 case PAD_SHAPE::OVAL:
 {
 double dx = scale( aPad->GetSize().x ) / 2.0;
 double dy = scale( aPad->GetSize().y ) / 2.0;
 double dr = dx - dy;
 double radius;
 POINT pstart;
 POINT pstop;
 
 if( dr >= 0 ) // oval is horizontal
 {
 radius = dy;
 
 pstart = POINT( -dr, 0.0 );
 pstop = POINT( dr, 0.0 );
 }
 else // oval is vertical
 {
 radius = dx;
 dr = -dr;
 
 pstart = POINT( 0.0, -dr );
 pstop = POINT( 0.0, dr );
 }
 
 pstart += dsnOffset;
 pstop += dsnOffset;
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
 SHAPE* shape;
 PATH* path;
 
 // see http://www.freerouting.net/usren/viewtopic.php?f=3&t=317#p408
 shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 path = makePath( pstart, pstop, layerName[ndx] );
 shape->SetShape( path );
 path->aperture_width = 2.0 * radius;
 }
 
 snprintf( name, sizeof( name ), "Oval%sPad_%.6gx%.6g_um", uniqifier.c_str(),
 IU2um( aPad->GetSize().x ), IU2um( aPad->GetSize().y ) );
 name[sizeof( name ) - 1] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 
 case PAD_SHAPE::TRAPEZOID:
 {
 double dx = scale( aPad->GetSize().x ) / 2.0;
 double dy = scale( aPad->GetSize().y ) / 2.0;
 
 double ddx = scale( aPad->GetDelta().x ) / 2.0;
 double ddy = scale( aPad->GetDelta().y ) / 2.0;
 
 // see class_pad_draw_functions.cpp which draws the trapezoid pad
 POINT lowerLeft( -dx - ddy, -dy - ddx );
 POINT upperLeft( -dx + ddy, +dy + ddx );
 POINT upperRight( +dx - ddy, +dy - ddx );
 POINT lowerRight( +dx + ddy, -dy + ddx );
 
 lowerLeft += dsnOffset;
 upperLeft += dsnOffset;
 upperRight += dsnOffset;
 lowerRight += dsnOffset;
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
  SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 // a T_polygon exists as a PATH
 PATH* polygon = new PATH( shape, T_polygon );
 
 shape->SetShape( polygon );
 
 polygon->SetLayerId( layerName[ndx] );
 
 polygon->AppendPoint( lowerLeft );
 polygon->AppendPoint( upperLeft );
 polygon->AppendPoint( upperRight );
 polygon->AppendPoint( lowerRight );
 }
 
 // this string _must_ be unique for a given physical shape
 snprintf( name, sizeof( name ), "Trapz%sPad_%.6gx%.6g_%c%.6gx%c%.6g_um", uniqifier.c_str(),
 IU2um( aPad->GetSize().x ), IU2um( aPad->GetSize().y ),
 aPad->GetDelta().x < 0 ? 'n' : 'p', std::abs( IU2um( aPad->GetDelta().x ) ),
 aPad->GetDelta().y < 0 ? 'n' : 'p', std::abs( IU2um( aPad->GetDelta().y ) ) );
 name[sizeof( name ) - 1] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 
 case PAD_SHAPE::CHAMFERED_RECT:
 case PAD_SHAPE::ROUNDRECT:
 {
 // Export the shape as as polygon, round rect does not exist as primitive
 const int circleToSegmentsCount = 36;
 int rradius = aPad->GetRoundRectCornerRadius();
 SHAPE_POLY_SET cornerBuffer;
 
 // Use a slightly bigger shape because the round corners are approximated by
 // segments, giving to the polygon a slightly smaller shape than the actual shape
 
 /* calculates the coeff to compensate radius reduction of holes clearance
 * due to the segment approx.
 * For a circle the min radius is radius * cos( 2PI / s_CircleToSegmentsCount / 2)
 * correctionFactor is cos( PI/s_CircleToSegmentsCount )
 */
 double correctionFactor = cos( M_PI / (double) circleToSegmentsCount );
 int extra_clearance = KiROUND( rradius * ( 1.0 - correctionFactor ) );
 VECTOR2I psize = aPad->GetSize();
 psize.x += extra_clearance * 2;
 psize.y += extra_clearance * 2;
 rradius += extra_clearance;
 bool doChamfer = aPad->GetShape() == PAD_SHAPE::CHAMFERED_RECT;
 
 TransformRoundChamferedRectToPolygon( cornerBuffer, VECTOR2I( 0, 0 ), psize, ANGLE_0,
 rradius, aPad->GetChamferRectRatio(),
 doChamfer ? aPad->GetChamferPositions() : 0,
 0, aBoard->GetDesignSettings().m_MaxError,
 ERROR_INSIDE );
 
 SHAPE_LINE_CHAIN& polygonal_shape = cornerBuffer.Outline( 0 );
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
 SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 // a T_polygon exists as a PATH
 PATH* polygon = new PATH( shape, T_polygon );
 
 shape->SetShape( polygon );
 
 polygon->SetLayerId( layerName[ndx] );
 
 // append a closed polygon
 POINT first_corner;
 
 for( int idx = 0; idx < polygonal_shape.PointCount(); idx++ )
 {
 POINT corner( scale( polygonal_shape.CPoint( idx ).x ),
 scale( -polygonal_shape.CPoint( idx ).y ) );
 corner += dsnOffset;
 polygon->AppendPoint( corner );
 
 if( idx == 0 )
 first_corner = corner;
 }
 
 polygon->AppendPoint( first_corner ); // Close polygon
 }
 
 // this string _must_ be unique for a given physical shape
 snprintf( name, sizeof( name ), "RoundRect%sPad_%.6gx%.6g_%.6g_um_%f_%X", uniqifier.c_str(),
 IU2um( aPad->GetSize().x ), IU2um( aPad->GetSize().y ), IU2um( rradius ),
 doChamfer ? aPad->GetChamferRectRatio() : 0.0,
 doChamfer ? aPad->GetChamferPositions() : 0 );
 
 name[sizeof( name ) - 1] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 
 case PAD_SHAPE::CUSTOM:
 {
 std::vector<VECTOR2I> polygonal_shape;
 SHAPE_POLY_SET pad_shape;
 aPad->MergePrimitivesAsPolygon( &pad_shape );
 
#ifdef EXPORT_CUSTOM_PADS_CONVEX_HULL
 BuildConvexHull( polygonal_shape, pad_shape );
#else
 const SHAPE_LINE_CHAIN& p_outline = pad_shape.COutline( 0 );
 
 for( int ii = 0; ii < p_outline.PointCount(); ++ii )
 polygonal_shape.push_back( wxPoint( p_outline.CPoint( ii ) ) );
#endif
 
 // The polygon must be closed
 if( polygonal_shape.front() != polygonal_shape.back() )
 polygonal_shape.push_back( polygonal_shape.front() );
 
 for( int ndx = 0; ndx < reportedLayers; ++ndx )
 {
 SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 // a T_polygon exists as a PATH
 PATH* polygon = new PATH( shape, T_polygon );
 
 shape->SetShape( polygon );
 
 polygon->SetLayerId( layerName[ndx] );
 
 for( unsigned idx = 0; idx < polygonal_shape.size(); idx++ )
 {
 POINT corner( scale( polygonal_shape[idx].x ), scale( -polygonal_shape[idx].y ) );
 corner += dsnOffset;
 polygon->AppendPoint( corner );
 }
 }
 
 // this string _must_ be unique for a given physical shape, so try to make it unique
 MD5_HASH hash = pad_shape.GetHash();
 BOX2I rect = aPad->GetBoundingBox();
 snprintf( name, sizeof( name ), "Cust%sPad_%.6gx%.6g_%.6gx_%.6g_%d_um_%s",
 uniqifier.c_str(), IU2um( aPad->GetSize().x ), IU2um( aPad->GetSize().y ),
 IU2um( rect.GetWidth() ), IU2um( rect.GetHeight() ), (int) polygonal_shape.size(),
 hash.Format( true ).c_str() );
 name[sizeof( name ) - 1] = 0;
 
 padstack->SetPadstackId( name );
 break;
 }
 }
 
 return padstack;
}

References std::abs(), LSET::AllCuMask(), ANGLE_0, DSN::ELEM_HOLDER::Append(), DSN::PATH::AppendPoint(), BuildConvexHull(), CHAMFERED_RECT, CIRCLE, SHAPE_POLY_SET::COutline(), SHAPE_LINE_CHAIN::CPoint(), CUSTOM, ERROR_INSIDE, MD5_HASH::Format(), PAD::GetBoundingBox(), PAD::GetChamferPositions(), PAD::GetChamferRectRatio(), BOARD::GetCopperLayerCount(), PAD::GetDelta(), BOARD::GetDesignSettings(), SHAPE_POLY_SET::GetHash(), BOX2< Vec >::GetHeight(), PAD::GetLayerSet(), PAD::GetOffset(), PAD::GetRoundRectCornerRadius(), PAD::GetShape(), PAD::GetSize(), BOX2< Vec >::GetWidth(), PAD::IsOnLayer(), DSN::isRoundKeepout(), DSN::IU2um(), KiROUND(), m_layerIds, BOARD_DESIGN_SETTINGS::m_MaxError, m_pcbLayer2kicad, DSN::makePath(), DSN::mapPt(), MAX_CU_LAYERS, PAD::MergePrimitivesAsPolygon(), name, SHAPE_POLY_SET::Outline(), OVAL, path, SHAPE_LINE_CHAIN::PointCount(), RECT, ROUNDRECT, DSN::scale(), DSN::RECTANGLE::SetCorners(), DSN::CIRCLE::SetDiameter(), DSN::RECTANGLE::SetLayerId(), DSN::PATH::SetLayerId(), DSN::CIRCLE::SetLayerId(), DSN::PADSTACK::SetPadstackId(), DSN::WINDOW::SetShape(), DSN::CIRCLE::SetVertex(), TransformRoundChamferedRectToPolygon(), TRAPEZOID, VECTOR2< T >::x, DSN::POINT::x, VECTOR2< T >::y, and DSN::POINT::y.

Referenced by makeIMAGE().

MakePCB()

PCB * DSN::SPECCTRA_DB::MakePCB ( )

static

Make a PCB with all the default ELEMs and parts on the heap.

Definition at line 3722 of file specctra.cpp.

{
 PCB* pcb = new PCB();
 
 pcb->parser = new PARSER( pcb );
 pcb->resolution = new UNIT_RES( pcb, T_resolution );
 pcb->unit = new UNIT_RES( pcb, T_unit );
 
 pcb->structure = new STRUCTURE( pcb );
 pcb->structure->boundary = new BOUNDARY( pcb->structure );
 pcb->structure->via = new VIA( pcb->structure );
 pcb->structure->rules = new RULE( pcb->structure, T_rule );
 
 pcb->placement = new PLACEMENT( pcb );
 
 pcb->library = new LIBRARY( pcb );
 
 pcb->network = new NETWORK( pcb );
 
 pcb->wiring = new WIRING( pcb );
 
 return pcb;
}

References DSN::STRUCTURE::boundary, DSN::PCB::library, DSN::PCB::network, DSN::PCB::parser, DSN::PCB::placement, DSN::PCB::resolution, RULE, DSN::STRUCTURE::rules, DSN::PCB::structure, DSN::PCB::unit, VIA, DSN::STRUCTURE::via, and DSN::PCB::wiring.

Referenced by FromBOARD().

makeTRACK()

PCB_TRACK * DSN::SPECCTRA_DB::makeTRACK ( WIRE *  wire, PATH *  aPath, int  aPointIndex, int  aNetcode  )

private

Create a #TRACK form the #PATH and BOARD info.

Definition at line 153 of file specctra_import.cpp.

{
 int layerNdx = findLayerName( aPath->layer_id );
 
 if( layerNdx == -1 )
 {
 THROW_IO_ERROR( wxString::Format( _( "Session file uses invalid layer id '%s'." ),
 FROM_UTF8( aPath->layer_id.c_str() ) ) );
 }
 
 PCB_TRACK* track = new PCB_TRACK( m_sessionBoard );
 
 track->SetStart( mapPt( aPath->points[aPointIndex+0], m_routeResolution ) );
 track->SetEnd( mapPt( aPath->points[aPointIndex+1], m_routeResolution ) );
 track->SetLayer( m_pcbLayer2kicad[layerNdx] );
 track->SetWidth( scale( aPath->aperture_width, m_routeResolution ) );
 track->SetNetCode( aNetcode );
 
 // a track can be locked.
 // However specctra as 4 types, none is exactly the same as our locked option
 // wire->wire_type = T_fix, T_route, T_normal or T_protect
 // fix and protect could be used as lock option
 // but protect is returned for all tracks having initially the route or protect property
 if( wire->wire_type == T_fix )
 track->SetLocked( true );
 
 return track;
}

References _, DSN::PATH::aperture_width, findLayerName(), Format(), FROM_UTF8(), DSN::PATH::layer_id, m_pcbLayer2kicad, m_routeResolution, m_sessionBoard, DSN::mapPt(), DSN::PATH::points, DSN::scale(), PCB_TRACK::SetEnd(), BOARD_ITEM::SetLayer(), BOARD_ITEM::SetLocked(), BOARD_CONNECTED_ITEM::SetNetCode(), PCB_TRACK::SetStart(), PCB_TRACK::SetWidth(), THROW_IO_ERROR, and DSN::WIRE::wire_type.

Referenced by FromSESSION().

makeVia() [1/2]

PADSTACK * DSN::SPECCTRA_DB::makeVia ( const ::PCB_VIA *  aVia )

private

Make any kind of #PADSTACK using the given KiCad #VIA.

Parameters

aVia	The #VIA to build the padstack from.

Returns

The padstack, which is on the heap only, user must save or delete it.

makeVia() [2/2]

PADSTACK * DSN::SPECCTRA_DB::makeVia ( int  aCopperDiameter, int  aDrillDiameter, int  aTopLayer, int  aBotLayer  )

private

Make a round through hole #PADSTACK using the given KiCad diameter in deci-mils.

Parameters

aCopperDiameter	The diameter of the copper pad.
aDrillDiameter	The drill diameter, used on re-import of the session file.
aTopLayer	The DSN::PCB top most layer index.
aBotLayer	The DSN::PCB bottom most layer index.

Returns

The padstack, which is on the heap only, user must save or delete it.

Definition at line 980 of file specctra_export.cpp.

{
 char name[48];
 PADSTACK* padstack = new PADSTACK();
 double dsnDiameter = scale( aCopperDiameter );
 
 for( int layer=aTopLayer; layer<=aBotLayer; ++layer )
 {
 SHAPE* shape = new SHAPE( padstack );
 
 padstack->Append( shape );
 
 CIRCLE* circle = new CIRCLE( shape );
 
 shape->SetShape( circle );
 
 circle->SetDiameter( dsnDiameter );
 circle->SetLayerId( m_layerIds[layer].c_str() );
 }
 
 snprintf( name, sizeof( name ), "Via[%d-%d]_%.6g:%.6g_um",
 aTopLayer, aBotLayer, dsnDiameter,
 // encode the drill value into the name for later import
 IU2um( aDrillDiameter ) );
 
 name[ sizeof(name) - 1 ] = 0;
 padstack->SetPadstackId( name );
 
 return padstack;
}

References DSN::ELEM_HOLDER::Append(), DSN::IU2um(), m_layerIds, name, DSN::scale(), DSN::CIRCLE::SetDiameter(), DSN::CIRCLE::SetLayerId(), DSN::PADSTACK::SetPadstackId(), and DSN::WINDOW::SetShape().

Referenced by exportNETCLASS(), and FromBOARD().

makeVIA()

PCB_VIA * DSN::SPECCTRA_DB::makeVIA ( WIRE_VIA *  aVia, PADSTACK *  aPadstack, const POINT &  aPoint, int  aNetCode, int  aViaDrillDefault  )

private

Instantiate a KiCad #VIA on the heap and initializes it with internal values consistent with the given #PADSTACK, #POINT, and netcode.

Definition at line 183 of file specctra_import.cpp.

{
 PCB_VIA* via = 0;
 SHAPE* shape;
 int shapeCount = aPadstack->Length();
 int drill_diam_iu = -1;
 int copperLayerCount = m_sessionBoard->GetCopperLayerCount();
 
 
 // The drill diameter is encoded in the padstack name if Pcbnew did the DSN export.
 // It is after the colon and before the last '_'
 int drillStartNdx = aPadstack->padstack_id.find( ':' );
 
 if( drillStartNdx != -1 )
 {
 ++drillStartNdx; // skip over the ':'
 
 int drillEndNdx = aPadstack->padstack_id.rfind( '_' );
 if( drillEndNdx != -1 )
 {
 std::string diam_txt( aPadstack->padstack_id,
 drillStartNdx, drillEndNdx-drillStartNdx );
 
 double drill_um = strtod( diam_txt.c_str(), 0 );
 
 drill_diam_iu = int( drill_um * ( pcbIUScale.IU_PER_MM / 1000.0 ) );
 
 if( drill_diam_iu == aViaDrillDefault )
 drill_diam_iu = UNDEFINED_DRILL_DIAMETER;
 }
 }
 
 if( shapeCount == 0 )
 {
 THROW_IO_ERROR( _( "Session via padstack has no shapes" ) );
 }
 else if( shapeCount == 1 )
 {
 shape = (SHAPE*) (*aPadstack)[0];
 DSN_T type = shape->shape->Type();
 
 if( type != T_circle )
 {
 THROW_IO_ERROR( wxString::Format( _( "Unsupported via shape: %s." ),
 GetTokenString( type ) ) );
 }
 
 CIRCLE* circle = (CIRCLE*) shape->shape;
 int viaDiam = scale( circle->diameter, m_routeResolution );
 
 via = new PCB_VIA( m_sessionBoard );
 via->SetPosition( mapPt( aPoint, m_routeResolution ) );
 via->SetDrill( drill_diam_iu );
 via->SetViaType( VIATYPE::THROUGH );
 via->SetWidth( viaDiam );
 via->SetLayerPair( F_Cu, B_Cu );
 }
 else if( shapeCount == copperLayerCount )
 {
 shape = (SHAPE*) (*aPadstack)[0];
 DSN_T type = shape->shape->Type();
 
 if( type != T_circle )
 {
 THROW_IO_ERROR( wxString::Format( _( "Unsupported via shape: %s" ),
 GetTokenString( type ) ) );
 }
 
 CIRCLE* circle = (CIRCLE*) shape->shape;
 int viaDiam = scale( circle->diameter, m_routeResolution );
 
 via = new PCB_VIA( m_sessionBoard );
 via->SetPosition( mapPt( aPoint, m_routeResolution ) );
 via->SetDrill( drill_diam_iu );
 via->SetViaType( VIATYPE::THROUGH );
 via->SetWidth( viaDiam );
 via->SetLayerPair( F_Cu, B_Cu );
 }
 else // VIA_MICROVIA or VIA_BLIND_BURIED
 {
 int topLayerNdx = -1; // session layer detectors
 int botLayerNdx = INT_MAX;
 
 int viaDiam = -1;
 
 for( int i=0; i<shapeCount; ++i )
 {
 shape = (SHAPE*) (*aPadstack)[i];
 DSN_T type = shape->shape->Type();
 
 if( type != T_circle )
 {
 THROW_IO_ERROR( wxString::Format( _( "Unsupported via shape: %s" ),
 GetTokenString( type ) ) );
 }
 
 CIRCLE* circle = (CIRCLE*) shape->shape;
 
 int layerNdx = findLayerName( circle->layer_id );
 if( layerNdx == -1 )
 {
 wxString layerName = FROM_UTF8( circle->layer_id.c_str() );
 THROW_IO_ERROR( wxString::Format( _( "Session file uses invalid layer id '%s'" ),
 layerName ) );
 }
 
 if( layerNdx > topLayerNdx )
 topLayerNdx = layerNdx;
 
 if( layerNdx < botLayerNdx )
 botLayerNdx = layerNdx;
 
 if( viaDiam == -1 )
 viaDiam = scale( circle->diameter, m_routeResolution );
 }
 
 via = new PCB_VIA( m_sessionBoard );
 via->SetPosition( mapPt( aPoint, m_routeResolution ) );
 via->SetDrill( drill_diam_iu );
 
 if( ( topLayerNdx == 0 && botLayerNdx == 1 )
 || ( topLayerNdx == copperLayerCount-2 && botLayerNdx == copperLayerCount-1 ) )
 {
 via->SetViaType( VIATYPE::MICROVIA );
 }
 else
 {
 via->SetViaType( VIATYPE::BLIND_BURIED );
 }
 
 via->SetWidth( viaDiam );
 via->SetLayerPair( m_pcbLayer2kicad[ topLayerNdx ], m_pcbLayer2kicad[ botLayerNdx ] );
 }
 
 wxASSERT( via );
 
 via->SetNetCode( aNetCode );
 
 // a via can be locked.
 // However specctra as 4 types, none is exactly the same as our locked option
 // aVia->via_type = T_fix, T_route, T_normal or T_protect
 // fix and protect could be used as lock option
 // but protect is returned for all tracks having initially the route or protect property
 if( aVia->via_type == T_fix )
 via->SetLocked( true );
 
 return via;
}

References _, B_Cu, BLIND_BURIED, DSN::CIRCLE::diameter, F_Cu, findLayerName(), Format(), FROM_UTF8(), BOARD::GetCopperLayerCount(), EDA_IU_SCALE::IU_PER_MM, DSN::CIRCLE::layer_id, DSN::ELEM_HOLDER::Length(), m_pcbLayer2kicad, m_routeResolution, m_sessionBoard, DSN::mapPt(), MICROVIA, DSN::PADSTACK::padstack_id, pcbIUScale, DSN::scale(), DSN::WINDOW::shape, THROUGH, THROW_IO_ERROR, DSN::ELEM::Type(), UNDEFINED_DRILL_DIAMETER, via, and DSN::WIRE_VIA::via_type.

Referenced by FromSESSION().

readCOMPnPIN()

void DSN::SPECCTRA_DB::readCOMPnPIN ( std::string *  component_id, std::string *  pid_id  )

private

Read a <pin_reference> and splits it into the two parts which are on either side of the hyphen.

This function is specialized because pin_reference may or may not be using double quotes. Both of these are legal: U2-14 or "U2"-"14". The lexer treats the first one as a single T_SYMBOL, so in that case we have to split it into two here.

The caller should have already read in the first token comprising the pin_reference and it will be tested through CurTok().

Parameters

component_id	Where to put the text preceding the '-' hyphen.
pid_id	Where to put the text which trails the '-'.

Exceptions

IO_ERROR,if

the next token or two do no make up a pin_reference, or there is an error reading from the input stream.

Definition at line 137 of file specctra.cpp.

{
 T tok;
 
 static const char pin_def[] = "<pin_reference>::=<component_id>-<pin_id>";
 
 if( !IsSymbol( (T) CurTok() ) )
 Expecting( pin_def );
 
 // case for: A12-14, i.e. no wrapping quotes. This should be a single
 // token, so split it.
 if( CurTok() != T_STRING )
 {
 const char* toktext = CurText();
 const char* dash = strchr( toktext, '-' );
 
 if( !dash )
 Expecting( pin_def );
 
 while( toktext != dash )
 *component_id += *toktext++;
 
 ++toktext; // skip the dash
 
 while( *toktext )
 *pin_id += *toktext++;
 }
 else // quoted string: "U12"-"14" or "U12"-14, 3 tokens in either case
 {
 *component_id = CurText();
 
 tok = NextTok();
 
 if( tok!=T_DASH )
 Expecting( pin_def );
 
 NextTok(); // accept anything after the dash.
 *pin_id = CurText();
 }
}

Referenced by doNET(), doSUPPLY_PIN(), and doWAS_IS().

readTIME()

void DSN::SPECCTRA_DB::readTIME ( time_t *  time_stamp )

private

Read a <time_stamp> which consists of 8 lexer tokens: "month date hour : minute : second year".

This function is specialized because time_stamps occur more than once in a session file. The caller should not have already read in the first token comprising the time stamp.

Parameters

time_stamp

Where to put the parsed time value.

Exceptions

IO_ERROR,if

the next token or 8 do no make up a time stamp, or there is an error reading from the input stream.

Definition at line 179 of file specctra.cpp.

{
 T tok;
 
 struct tm mytime;
 
 static const char time_toks[] = "<month> <day> <hour> : <minute> : <second> <year>";
 
 static const char* months[] = { // index 0 = Jan
 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", nullptr
 };
 
 NeedSYMBOL(); // month
 
 const char* ptok = CurText();
 
 mytime.tm_mon = 0; // remains if we don't find a month match.
 
 for( int m = 0; months[m]; ++m )
 {
 if( !strcasecmp( months[m], ptok ) )
 {
 mytime.tm_mon = m;
 break;
 }
 }
 
 tok = NextTok(); // day
 
 if( tok != T_NUMBER )
 Expecting( time_toks );
 
 mytime.tm_mday = atoi( CurText() );
 
 tok = NextTok(); // hour
 
 if( tok != T_NUMBER )
 Expecting( time_toks );
 
 mytime.tm_hour = atoi( CurText() );
 
 // : colon
 NeedSYMBOL();
 
 if( *CurText() != ':' || strlen( CurText() )!=1 )
 Expecting( time_toks );
 
 tok = NextTok(); // minute
 
 if( tok != T_NUMBER )
 Expecting( time_toks );
 
 mytime.tm_min = atoi( CurText() );
 
 // : colon
 NeedSYMBOL();
 
 if( *CurText() != ':' || strlen( CurText() )!=1 )
 Expecting( time_toks );
 
 tok = NextTok(); // second
 
 if( tok != T_NUMBER )
 Expecting( time_toks );
 
 mytime.tm_sec = atoi( CurText() );
 
 tok = NextTok(); // year
 
 if( tok != T_NUMBER )
 Expecting( time_toks );
 
 mytime.tm_year = atoi( CurText() ) - 1900;
 
 *time_stamp = mktime( &mytime );
}

Referenced by doANCESTOR(), and doHISTORY().

RevertFOOTPRINTs()

void DSN::SPECCTRA_DB::RevertFOOTPRINTs

(

BOARD *

aBoard

)

Flip the footprints which were on the back side of the board back to the back.

Definition at line 1810 of file specctra_export.cpp.

{
 if( !m_footprintsAreFlipped )
 return;
 
 // DSN Images (=KiCad FOOTPRINTs and PADs) must be presented from the
 // top view. Restore those that were flipped.
 // Note: to export footprints, the footprints were flipped around the X axis,
 for( FOOTPRINT* footprint : aBoard->Footprints() )
 {
 if( footprint->GetFlag() )
 {
 footprint->Flip( footprint->GetPosition(), false );
 footprint->SetFlag( 0 );
 }
 }
 
 m_footprintsAreFlipped = false;
}

References BOARD::Footprints(), and m_footprintsAreFlipped.

Referenced by ExportBoardToSpecctraFile().

SetPCB()

void DSN::SPECCTRA_DB::SetPCB ( PCB *  aPcb )

inline

Delete any existing PCB and replaces it with the given one.

Definition at line 3688 of file specctra.h.

 {
 delete m_pcb;
 m_pcb = aPcb;
 }

References m_pcb.

Referenced by ExportBoardToSpecctraFile(), and LoadPCB().

SetSESSION()

void DSN::SPECCTRA_DB::SetSESSION ( SESSION *  aSession )

inline

Delete any existing SESSION and replaces it with the given one.

Definition at line 3699 of file specctra.h.

 {
 delete m_session;
 m_session = aSession;
 }

References m_session.

Referenced by LoadSESSION().

Member Data Documentation

keywords

const KEYWORD DSN::SPECCTRA_DB::keywords[]

staticprivate

specctra DSN keywords

Definition at line 3977 of file specctra.h.

m_bot_via_layer

int DSN::SPECCTRA_DB::m_bot_via_layer

private

Definition at line 4009 of file specctra.h.

Referenced by exportNETCLASS(), FromBOARD(), and SPECCTRA_DB().

m_brd_outlines

SHAPE_POLY_SET DSN::SPECCTRA_DB::m_brd_outlines

private

Definition at line 3980 of file specctra.h.

Referenced by BuiltBoardOutlines(), and fillBOUNDARY().

m_filename

wxString DSN::SPECCTRA_DB::m_filename

private

Definition at line 3982 of file specctra.h.

m_footprintsAreFlipped

bool DSN::SPECCTRA_DB::m_footprintsAreFlipped

private

Definition at line 3985 of file specctra.h.

Referenced by FlipFOOTPRINTs(), RevertFOOTPRINTs(), and SPECCTRA_DB().

m_kicadLayer2pcb

std::vector<int> DSN::SPECCTRA_DB::m_kicadLayer2pcb

private

maps BOARD layer number to PCB layer numbers

Definition at line 3991 of file specctra.h.

Referenced by buildLayerMaps(), FromBOARD(), and makeIMAGE().

m_layerIds

STRINGS DSN::SPECCTRA_DB::m_layerIds

private

indexed by PCB layer number

Definition at line 3989 of file specctra.h.

Referenced by buildLayerMaps(), findLayerName(), FromBOARD(), makeIMAGE(), makePADSTACK(), and makeVia().

m_nets

std::vector<NET*> DSN::SPECCTRA_DB::m_nets

private

we don't want ownership here permanently, so we don't use boost::ptr_vector

Definition at line 4005 of file specctra.h.

Referenced by deleteNETs(), and FromBOARD().

m_padstackset

PADSTACKSET DSN::SPECCTRA_DB::m_padstackset

private

Definition at line 4002 of file specctra.h.

Referenced by FromBOARD(), and makeIMAGE().

m_pcb

PCB* DSN::SPECCTRA_DB::m_pcb

private

Definition at line 3979 of file specctra.h.

Referenced by exportNETCLASS(), ExportPCB(), fillBOUNDARY(), FromBOARD(), GetPCB(), LoadPCB(), makeIMAGE(), SetPCB(), SPECCTRA_DB(), and ~SPECCTRA_DB().

m_pcbLayer2kicad

std::vector<PCB_LAYER_ID> DSN::SPECCTRA_DB::m_pcbLayer2kicad

private

maps PCB layer number to BOARD layer numbers

Definition at line 3992 of file specctra.h.

Referenced by buildLayerMaps(), FromBOARD(), makePADSTACK(), makeTRACK(), and makeVIA().

m_quote_char

std::string DSN::SPECCTRA_DB::m_quote_char

private

Definition at line 3983 of file specctra.h.

Referenced by doCLASS(), doPARSER(), doRULE(), ExportPCB(), ExportSESSION(), and SPECCTRA_DB().

m_routeResolution

UNIT_RES* DSN::SPECCTRA_DB::m_routeResolution

private

used during FromSESSION() only, memory for it is not owned here.

Definition at line 3995 of file specctra.h.

Referenced by FromSESSION(), makeTRACK(), makeVIA(), and SPECCTRA_DB().

m_session

SESSION* DSN::SPECCTRA_DB::m_session

private

Definition at line 3981 of file specctra.h.

Referenced by ExportSESSION(), FromSESSION(), GetSESSION(), LoadSESSION(), SetSESSION(), SPECCTRA_DB(), and ~SPECCTRA_DB().

m_sessionBoard

BOARD* DSN::SPECCTRA_DB::m_sessionBoard

private

a copy to avoid passing as an argument, memory for it is not owned here.

Definition at line 3998 of file specctra.h.

Referenced by FromSESSION(), makeTRACK(), makeVIA(), and SPECCTRA_DB().

m_sf

STRING_FORMATTER DSN::SPECCTRA_DB::m_sf

private

Definition at line 3987 of file specctra.h.

m_top_via_layer

int DSN::SPECCTRA_DB::m_top_via_layer

private

specctra cu layers, 0 based index:

Definition at line 4008 of file specctra.h.

Referenced by exportNETCLASS(), FromBOARD(), and SPECCTRA_DB().

scanPADs

const KICAD_T DSN::SPECCTRA_DB::scanPADs[]

staticprivate

Definition at line 4000 of file specctra.h.

---

The documentation for this class was generated from the following files:

• specctra.h
• specctra.cpp
• specctra_export.cpp
• specctra_import.cpp