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 [] = { PCB_PAD_T, EOT }

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( LAYER_NUM kiNdx = layerCount - 1, pcbNdx=FIRST_LAYER; kiNdx >= 0; --kiNdx, ++pcbNdx )
 {
 LAYER_NUM 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 246 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 1795 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 and 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( NETCLASS::iterator net = aNetClass->begin(); net != aNetClass->end(); ++net )
 clazz->net_ids.push_back( TO_UTF8( *net ) );

 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 via (which generates
 // the name internal to the PADSTACK), and then grab the name and then
 // 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, 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 1045 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 1871 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 1096 of file specctra_export.cpp.

{
 PCB_TYPE_COLLECTOR items;

 static const KICAD_T scanMODULEs[] = { PCB_FOOTPRINT_T, EOT };

 // Not all boards are exportable. Check that all reference Ids are unique.
 // Unless they are unique, we cannot import the session file which comes
 // back to us later from the router.
 {
 items.Collect( aBoard, scanMODULEs );

 STRINGSET refs; // holds footprint reference designators

 for( int i=0; i<items.GetCount(); ++i )
 {
 FOOTPRINT* footprint = (FOOTPRINT*) items[i];

 if( footprint->GetReference() == wxEmptyString )
 {
 THROW_IO_ERROR( wxString::Format(
 _( "Symbol with value of '%s' has empty reference id." ),
 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 symbols have identical reference IDs of '%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.
 // @question : why does KiCad not display layers in that order?

 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];
 NETCLASS* defaultClass = aBoard->GetDesignSettings().GetDefault();

 int defaultTrackWidth = defaultClass->GetTrackWidth();
 int defaultClearance = defaultClass->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 (a board with 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
 // to 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 say 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;

 static const KICAD_T scanZONEs[] = { PCB_ZONE_T, EOT };
 items.Collect( aBoard, scanZONEs );

 for( int i = 0; i < items.GetCount(); ++i )
 {
 ZONE* item = (ZONE*) items[i];

 if( item->GetIsRuleArea() )
 continue;

 // Currently, we export only copper layers
 if( ! IsCopperLayer( item->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( item->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[ item->GetLayer() ] ];

 // Handle the main outlines
 SHAPE_POLY_SET::ITERATOR iterator;
 wxPoint startpoint;
 bool is_first_point = true;

 for( iterator = item->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[ item->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>--------------------------------
 {
 static const KICAD_T scanZONEs[] = { PCB_ZONE_T, EOT };
 items.Collect( aBoard, scanZONEs );

 for( int i = 0; i < items.GetCount(); ++i )
 {
 ZONE* item = (ZONE*) items[i];

 if( !item->GetIsRuleArea() )
 continue;

 // 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( item->GetDoNotAllowVias() && item->GetDoNotAllowTracks() )
 keepout_type = T_keepout;
 else if( item->GetDoNotAllowVias() )
 keepout_type = T_via_keepout;
 else if( item->GetDoNotAllowTracks() )
 keepout_type = T_wire_keepout;
 else
 keepout_type = T_keepout;

 // Now, build keepout polygon on each copper layer where the item
 // 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( !item->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 = item->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[ item->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;

 // find the highest numbered netCode within the board.
 int highestNetCode = 0;
 NETINFO_LIST& netInfo = aBoard->GetNetInfo();

 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() );
 }

 items.Collect( aBoard, scanMODULEs );

 m_padstackset.clear();

 for( int m = 0; m < items.GetCount(); ++m )
 {
 FOOTPRINT* footprint = (FOOTPRINT*) items[m];

 IMAGE* image = makeIMAGE( aBoard, footprint );

 componentId = TO_UTF8( footprint->GetReference() );

 // create a net list entry for all the actual pins in the image
 // for the current footprint. location of this code is critical
 // because we fabricated some pin names to ensure unique-ness
 // of pin names within a footprint, do not move this code because
 // 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() )
 {
 double angle = 180.0 - footprint->GetOrientationDegrees();
 NORMALIZE_ANGLE_DEGREES_POS( angle );
 place->SetRotation( angle );

 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 >-----------------------------------
 {
 NETCLASSES& nclasses = aBoard->GetDesignSettings().GetNetClasses();

 // 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.

 NETCLASSPTR netclass = nclasses.GetDefault();

 PADSTACK* via = makeVia( netclass->GetViaDiameter(), netclass->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( NETCLASSES::iterator nc = nclasses.begin(); nc != nclasses.end(); ++nc )
 {
 netclass = nc->second;

 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.
 static const KICAD_T scanTRACKs[] = { PCB_TRACE_T, PCB_ARC_T, EOT };

 items.Collect( aBoard, scanTRACKs );

 std::string netname;
 WIRING* wiring = m_pcb->wiring;
 PATH* path = 0;

 int old_netcode = -1;
 int old_width = -1;
 LAYER_NUM old_layer = UNDEFINED_LAYER;

 for( int i = 0; i < items.GetCount(); ++i )
 {
 PCB_TRACK* track = static_cast<PCB_TRACK*>( items[i] );
 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 returnned in .ses files
 else
 wire->wire_type = T_route; // could be T_protect

 LAYER_NUM 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.
 static const KICAD_T scanVIAs[] = { PCB_VIA_T, EOT };

 items.Collect( aBoard, scanVIAs );

 for( int i = 0; i<items.GetCount(); ++i )
 {
 PCB_VIA* via = static_cast<PCB_VIA*>( items[i] );
 wxASSERT( via->Type() == PCB_VIA_T );

 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 returnned 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>----------------------------------------------------
 NETCLASSES& nclasses = aBoard->GetDesignSettings().GetNetClasses();

 exportNETCLASS( nclasses.GetDefault(), aBoard );

 for( NETCLASSES::iterator nc = nclasses.begin(); nc != nclasses.end(); ++nc )
 {
 NETCLASSPTR netclass = nc->second;
 exportNETCLASS( netclass, aBoard );
 }
}

References _, DSN::LIBRARY::AddPadstack(), DSN::KEEPOUT::AddWindow(), PNS::angle(), DSN::PATH::AppendPoint(), DSN::VIA::AppendVia(), DSN::LIBRARY::AppendVia(), B_Cu, NETCLASSES::begin(), NETINFO_LIST::begin(), buildLayerMaps(), PCB_TYPE_COLLECTOR::Collect(), DSN::PLACE::component_id, DSN::PIN_REF::component_id, deleteNETs(), empty(), NETCLASSES::end(), NETINFO_LIST::end(), EOT, exportNETCLASS(), fillBOUNDARY(), BOARD::FindNet(), Format(), NETCLASS::GetClearance(), BOARD::GetCopperLayerCount(), COLLECTOR::GetCount(), NETCLASSES::GetDefault(), BOARD_DESIGN_SETTINGS::GetDefault(), BOARD::GetDesignSettings(), ZONE::GetDoNotAllowTracks(), ZONE::GetDoNotAllowVias(), PCB_TRACK::GetEnd(), FOOTPRINT::GetFlag(), ZONE::GetIsRuleArea(), BOARD_ITEM::GetLayer(), ZONE::GetLayer(), BOARD::GetLayerType(), BOARD_DESIGN_SETTINGS::GetNetClasses(), BOARD_CONNECTED_ITEM::GetNetCode(), BOARD::GetNetInfo(), BOARD_CONNECTED_ITEM::GetNetname(), NETINFO_ITEM::GetNetname(), FOOTPRINT::GetOrientationDegrees(), FOOTPRINT::GetPosition(), FOOTPRINT::GetReference(), PCB_TRACK::GetStart(), NETCLASS::GetTrackWidth(), FOOTPRINT::GetValue(), PCB_TRACK::GetWidth(), image, IsCopperLayer(), SHAPE_POLY_SET::ITERATOR_TEMPLATE< T >::IsEndContour(), BOARD_ITEM::IsLocked(), ZONE::IsOnLayer(), ZONE::IterateWithHoles(), 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, 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, NORMALIZE_ANGLE_DEGREES_POS(), DSN::WIRE_VIA::padstack_id, DSN::PCB::parser, DSN::PLACE::part_number, path, PCB_ARC_T, PCB_FOOTPRINT_T, PCB_TRACE_T, PCB_VIA_T, PCB_ZONE_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, 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, and DSN::PCB::wiring.

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 346 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 all 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.
 int orientation = KiROUND( place->rotation * 10.0 );

 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 )
 {
 int orientation = KiROUND( (place->rotation + 180.0) * 10.0 );

 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();
 }
 else // else netCode remains 0
 {
 // int breakhere = 1;
 }
 }

 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();

 // else netCode remains 0
 }

 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.


 // Could use a STRING_FORMATTER here and convert the entire
 // wire_via to text and put that text into the exception.
 wxString psid( FROM_UTF8( wire_via->GetPadstackId().c_str() ) );

 THROW_IO_ERROR( wxString::Format( _( "A wire_via refers to missing padstack '%s'." ),
 psid ) );
 }

 NETCLASSPTR netclass = aBoard->GetDesignSettings().GetNetClasses().GetDefault();

 int via_drill_default = netclass->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, BOARD::DeleteMARKERs(), F_Cu, BOARD::FindFootprintByReference(), BOARD::FindNet(), Format(), FROM_UTF8(), NETCLASSES::GetDefault(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetNetClasses(), NETINFO_ITEM::GetNetCode(), DSN::WIRE_VIA::GetPadstackId(), DSN::ELEM::GetUnits(), DSN::ROUTE::GetUnits(), DSN::PLACE::hasVertex, BOARD_ITEM::IsLocked(), KiROUND(), library, DSN::ROUTE::library, locked, m_routeResolution, m_session, m_sessionBoard, makeTRACK(), makeVIA(), DSN::mapPt(), DSN::ROUTE::net_outs, path, DSN::SESSION::placement, DSN::PLACE::rotation, DSN::SESSION::route, 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 612 of file specctra_export.cpp.

{
 PINMAP pinmap;
 wxString padNumber;

 PCB_TYPE_COLLECTOR fpItems;

 // get all the FOOTPRINT's pads.
 fpItems.Collect( aFootprint, scanPADs );

 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;

 double angle = pad->GetOrientationDegrees() - aFootprint->GetOrientationDegrees();
 NORMALIZE_ANGLE_DEGREES_POS( angle );
 pin->SetRotation( angle );

 wxPoint pos( pad->GetPos0() );

 pin->SetVertex( mapPt( pos ) );
 }
 }

 static const KICAD_T scanEDGEs[] = { PCB_FP_SHAPE_T, EOT };

  // get all the FOOTPRINT's FP_SHAPEs and convert those to DSN outlines.
 fpItems.Collect( aFootprint, scanEDGEs );

 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();
 wxPoint circle_centre = graphic->GetStart0();

 SHAPE_LINE_CHAIN polyline;
 ConvertArcToPolyline( polyline, VECTOR2I( circle_centre ), radius, 0.0, 360.0,
 ARC_HIGH_DEF, ERROR_INSIDE );

 for( int ii = 0; ii < polyline.PointCount(); ++ii )
 {
 wxPoint 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" );
 wxPoint 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" );

 wxPoint arc_centre = graphic->GetCenter0();
 double radius = graphic->GetRadius() + graphic->GetWidth()/2;
 double arcAngleDeg = graphic->GetArcAngle() / 10.0;

 VECTOR2I startRadial = graphic->GetStart() - graphic->GetCenter();
 double arcStartDeg = ArcTangente( startRadial.y, startRadial.x ) / 10;
 NORMALIZE_ANGLE_DEGREES_POS( arcStartDeg );

 // 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( arcAngleDeg < 0 )
 {
 VECTOR2I endRadial = graphic->GetEnd() - graphic->GetCenter();
 arcStartDeg = ArcTangente( endRadial.y, endRadial.x ) / 10;
 NORMALIZE_ANGLE_DEGREES_POS( arcStartDeg );

 arcAngleDeg = -arcAngleDeg;
 }

 SHAPE_LINE_CHAIN polyline;
 ConvertArcToPolyline( polyline, VECTOR2I( arc_centre ), radius, arcStartDeg,
 arcAngleDeg, 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, arcStartDeg,
 arcAngleDeg, 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 ) );

 wxPoint 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 )
 {
 wxPoint 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 );

 double angle = -aFootprint->GetOrientation();
 NORMALIZE_ANGLE_POS( angle );
 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;
 wxPoint startpoint;

 for( iterator = untransformedZone.IterateWithHoles(); iterator; iterator++ )
 {
 wxPoint 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 );

 wxPoint 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;
}