Initial commit of footprint library table code. (77e1a4c0) · Commits · Elphel / kicad-source-mirror

.bzrignore

+2 −0

Original line number	Original line	Diff line number	Diff line
	common/netlist_keywords.*		common/netlist_keywords.*
	common/netlist_lexer.h		common/netlist_lexer.h
	common/pcb_plot_params_lexer.h		common/pcb_plot_params_lexer.h
			common/fp_lib_table_keywords.*
			include/fp_lib_table_lexer.h
	include/netlist_lexer.h		include/netlist_lexer.h
	eeschema/cmp_library_lexer.h		eeschema/cmp_library_lexer.h
	eeschema/cmp_library_keywords.*		eeschema/cmp_library_keywords.*

CMakeLists.txt

+2 −4

Original line number	Original line	Diff line number	Diff line
	@@ -16,7 +16,7 @@ set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMakeModules)
	# KiCad build options should be added below.		# KiCad build options should be added below.
	#		#
	# If you add a new build option, please add it's state to the CopyVersionInfoToClipboard()		# If you add a new build option, please add it's state to the CopyVersionInfoToClipboard()
	# function in common/basicframe.cpp so that build option settings can be includeed in bug		# function in common/basicframe.cpp so that build option settings can be included in bug
	# reports.		# reports.
	#		#

	@@ -162,8 +162,6 @@ endif(KICAD_SCRIPTING_MODULES)

	if(KICAD_SCRIPTING_WXPYTHON)		if(KICAD_SCRIPTING_WXPYTHON)
	add_definitions(-DKICAD_SCRIPTING_WXPYTHON)		add_definitions(-DKICAD_SCRIPTING_WXPYTHON)


	endif(KICAD_SCRIPTING_WXPYTHON)		endif(KICAD_SCRIPTING_WXPYTHON)

	if(USE_WX_GRAPHICS_CONTEXT)		if(USE_WX_GRAPHICS_CONTEXT)
	@@ -171,7 +169,7 @@ if(USE_WX_GRAPHICS_CONTEXT)
	endif(USE_WX_GRAPHICS_CONTEXT)		endif(USE_WX_GRAPHICS_CONTEXT)

	# Allow user to override the default settings for adding images to menu items. By default		# Allow user to override the default settings for adding images to menu items. By default
	# images in menu items are enabled on all plaforms except OSX. This can be over ridden by		# images in menu items are enabled on all platforms except OSX. This can be over ridden by
	# defining -DUSE_IMAGES_IN_MENUS=ON/OFF to force the preferred behavior.		# defining -DUSE_IMAGES_IN_MENUS=ON/OFF to force the preferred behavior.
	if(NOT DEFINED USE_IMAGES_IN_MENUS)		if(NOT DEFINED USE_IMAGES_IN_MENUS)
	if(NOT APPLE)		if(NOT APPLE)

common/CMakeLists.txt

+10 −1

Original line number	Original line	Diff line number	Diff line
	@@ -124,6 +124,9 @@ set(PCB_COMMON_SRCS
	pcb_plot_params_keywords.cpp		pcb_plot_params_keywords.cpp
	pcb_keywords.cpp		pcb_keywords.cpp
	../pcbnew/pcb_parser.cpp		../pcbnew/pcb_parser.cpp
			fp_lib_table_keywords.cpp
			fp_lib_id.cpp
			fp_lib_table.cpp
	)		)


	@@ -155,9 +158,15 @@ make_lexer(
	make_lexer( ${CMAKE_CURRENT_SOURCE_DIR}/pcb.keywords		make_lexer( ${CMAKE_CURRENT_SOURCE_DIR}/pcb.keywords
	${PROJECT_SOURCE_DIR}/include/pcb_lexer.h		${PROJECT_SOURCE_DIR}/include/pcb_lexer.h
	${CMAKE_CURRENT_SOURCE_DIR}/pcb_keywords.cpp		${CMAKE_CURRENT_SOURCE_DIR}/pcb_keywords.cpp
	PCB		PCB_FILE_T
	)		)

			# auto-generate pcbnew s-expression footprint library table code.
			make_lexer( ${CMAKE_CURRENT_SOURCE_DIR}/fp_lib_table.keywords
			${PROJECT_SOURCE_DIR}/include/fp_lib_table_lexer.h
			${CMAKE_CURRENT_SOURCE_DIR}/fp_lib_table_keywords.cpp
			FP_LIB_TABLE_T
			)

	# The dsntest may not build properly using MS Visual Studio.		# The dsntest may not build properly using MS Visual Studio.
	if(NOT MSVC)		if(NOT MSVC)

common/fp_lib_id.cpp

0 → 100644

+413 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* This program source code file is part of KiCad, a free EDA CAD application.
			*
			* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
			* Copyright (C) 2010 KiCad Developers, see change_log.txt for contributors.
			*
			* This program is free software; you can redistribute it and/or
			* modify it under the terms of the GNU General Public License
			* as published by the Free Software Foundation; either version 2
			* of the License, or (at your option) any later version.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*
			* You should have received a copy of the GNU General Public License
			* along with this program; if not, you may find one here:
			* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
			* or you may search the http://www.gnu.org website for the version 2 license,
			* or you may write to the Free Software Foundation, Inc.,
			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
			*/

			#include <cstring>
			#include <wx/wx.h> // _()

			#include <fp_lib_id.h>


			static inline bool isDigit( char c )
			{
			return c >= '0' && c <= '9';
			}


			const char* EndsWithRev( const char* start, const char* tail, char separator )
			{
			bool sawDigit = false;

			while( tail > start && isDigit( *--tail ) )
			{
			sawDigit = true;
			}

			// if sawDigit, tail points to the 'v' here.

			if( sawDigit && tail-3 >= start )
			{
			tail -= 3;

			if( tail[0]==separator && tail[1]=='r' && tail[2]=='e' && tail[3]=='v' )
			{
			return tail+1; // omit separator, return "revN[N..]"
			}
			}

			return 0;
			}


			int RevCmp( const char* s1, const char* s2 )
			{
			int r = strncmp( s1, s2, 3 );

			if( r \|\| strlen(s1)<4 \|\| strlen(s2)<4 )
			{
			return r;
			}

			int rnum1 = atoi( s1+3 );
			int rnum2 = atoi( s2+3 );

			return -(rnum1 - rnum2); // swap the sign, higher revs first
			}

			//----<Policy and field test functions>-------------------------------------

			// These all return -1 on success, or >= 0 if there is an error at a
			// particular character offset into their respective arguments. If >=0,
			// then that return value gives the character offset of the error.


			static inline int okLogical( const std::string& aField )
			{
			// std::string::npos is largest positive number, casting to int makes it -1.
			// Returning that means success.
			return int( aField.find_first_of( ":/" ) );
			}


			static inline int okBase( const std::string& aField )
			{
			int offset = int( aField.find_first_of( ":/" ) );

			if( offset != -1 )
			return offset;

			// cannot be empty
			if( !aField.size() )
			return 0;

			return offset; // ie. -1
			}


			static int okRevision( const std::string& aField )
			{
			char rev[32]; // C string for speed

			if( aField.size() >= 4 )
			{
			strcpy( rev, "x/" );
			strcat( rev, aField.c_str() );

			if( EndsWithRev( rev, rev + strlen(rev) ) == rev+2 )
			return -1; // success
			}

			return 0; // first character position "is in error", is best we can do.
			}

			//----</Policy and field test functions>-------------------------------------


			void FP_LIB_ID::clear()
			{
			logical.clear();
			baseName.clear();
			footprintName.clear();
			revision.clear();
			}


			int FP_LIB_ID::Parse( const std::string& aId )
			{
			clear();

			const char* rev = EndsWithRev( aId );
			size_t revNdx;
			size_t partNdx;
			size_t baseNdx;
			int offset;

			//=====<revision>=========================================
			if( rev )
			{
			revNdx = rev - aId.c_str();

			// no need to check revision, EndsWithRev did that.
			revision = aId.substr( revNdx );
			--revNdx; // back up to omit the '/' which preceeds the rev
			}
			else
			revNdx = aId.size();

			//=====<logical>==========================================
			if( ( partNdx = aId.find( ':' ) ) != aId.npos )
			{
			offset = SetLogicalLib( aId.substr( 0, partNdx ) );
			if( offset > -1 )
			{
			return offset;
			}
			++partNdx; // skip ':'
			}
			else
			partNdx = 0;

			//=====<baseName>==========================================
			offset = SetBaseName( aId.substr( baseNdx, revNdx - baseNdx ) );

			if( offset > -1 )
			{
			return offset + baseNdx;
			}

			return -1;
			}


			FP_LIB_ID::FP_LIB_ID( const std::string& aId ) throw( PARSE_ERROR )
			{
			int offset = Parse( aId );

			if( offset != -1 )
			{
			THROW_PARSE_ERROR( _( "Illegal character found in FP_LIB_ID string" ),
			wxString::FromUTF8( aId.c_str() ),
			aId.c_str(),
			0,
			offset );
			}
			}


			int FP_LIB_ID::SetLogicalLib( const std::string& aLogical )
			{
			int offset = okLogical( aLogical );

			if( offset == -1 )
			{
			logical = aLogical;
			}

			return offset;
			}


			int FP_LIB_ID::SetBaseName( const std::string& aBaseName )
			{
			int offset = okBase( aBaseName );

			if( offset == -1 )
			{
			baseName = aBaseName;
			}

			return offset;
			}


			int FP_LIB_ID::SetFootprintName( const std::string& aFootprintName )
			{
			std::string base;
			int offset;
			int separation = int( aFootprintName.find_first_of( "/" ) );

			if( separation != -1 )
			{
			base = aFootprintName.substr( separation+1 );
			}
			else
			{
			base = aFootprintName;
			}

			if( (offset = SetBaseName( base )) != -1 )
			{
			return offset + separation + 1;
			}

			return -1;
			}


			int FP_LIB_ID::SetRevision( const std::string& aRevision )
			{
			int offset = okRevision( aRevision );

			if( offset == -1 )
			{
			revision = aRevision;
			}

			return offset;
			}


			std::string FP_LIB_ID::Format() const
			{
			std::string ret;

			if( logical.size() )
			{
			ret += logical;
			ret += ':';
			}

			ret += baseName;

			if( revision.size() )
			{
			ret += '/';
			ret += revision;
			}

			return ret;
			}


			std::string FP_LIB_ID::GetFootprintNameAndRev() const
			{
			std::string ret;

			ret += baseName;

			if( revision.size() )
			{
			ret += '/';
			ret += revision;
			}

			return ret;
			}


			std::string FP_LIB_ID::Format( const std::string& aLogicalLib, const std::string& aFootprintName,
			const std::string& aRevision )
			throw( PARSE_ERROR )
			{
			std::string ret;
			int offset;

			if( aLogicalLib.size() )
			{
			offset = okLogical( aLogicalLib );

			if( offset != -1 )
			{
			THROW_PARSE_ERROR( _( "Illegal character found in logical lib name" ),
			wxString::FromUTF8( aLogicalLib.c_str() ),
			aLogicalLib.c_str(),
			0,
			offset );
			}

			ret += aLogicalLib;
			ret += ':';
			}

			{
			std::string base;

			int separation = int( aFootprintName.find_first_of( "/" ) );

			if( separation != -1 )
			{
			base = aFootprintName.substr( separation+1 );
			}
			else
			{
			base = aFootprintName;
			}


			if( (offset = okBase( base )) != -1 )
			{
			THROW_PARSE_ERROR( _( "Illegal character found in base name" ),
			wxString::FromUTF8( aRevision.c_str() ),
			aRevision.c_str(),
			0,
			offset + separation + 1 );
			}

			ret += base;
			}

			if( aRevision.size() )
			{
			offset = okRevision( aRevision );

			if( offset != -1 )
			{
			THROW_PARSE_ERROR( _( "Illegal character found in revision" ),
			wxString::FromUTF8( aRevision.c_str() ),
			aRevision.c_str(),
			0,
			offset );
			}

			ret += '/';
			ret += aRevision;
			}

			return ret;
			}


			#if 0 && defined(DEBUG)

			// build this with Debug CMAKE_BUILD_TYPE

			void FP_LIB_ID::Test()
			{
			static const char* lpids[] = {
			"/R/rev0",
			"passives/R/rev2",
			":passives/R/rev3",
			"C/rev22",
			"passives/C22",
			"R",
			"me:R",
			// most difficult:
			"me:/R/rev0",
			"me:R/rev0",
			};

			for( unsigned i=0; i<sizeof(lpids)/sizeof(lpids[0]); ++i )
			{
			// test some round tripping

			FP_LIB_ID lpid( lpids[i] ); // parse

			// format
			printf( "input:'%s' full:'%s' base:'%s' footprintName:'%s' rev:'%s'\n",
			lpids[i],
			lpid.Format().c_str(),
			lpid.GetBaseName().c_str(),
			lpid.GetFootprintName().c_str(),
			lpid.GetRevision().c_str() );
			}
			}


			int main( int argc, char** argv )
			{
			FP_LIB_ID::Test();

			return 0;
			}

			#endif

common/fp_lib_table.cpp

0 → 100644

+312 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* This program source code file is part of KiCad, a free EDA CAD application.
			*
			* Copyright (C) 2010 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
			* Copyright (C) 2012 Wayne Stambaugh <stambaughw@verizon.net>
			* Copyright (C) 2012 KiCad Developers, see change_log.txt for contributors.
			*
			* This program is free software; you can redistribute it and/or
			* modify it under the terms of the GNU General Public License
			* as published by the Free Software Foundation; either version 2
			* of the License, or (at your option) any later version.
			*
			* This program is distributed in the hope that it will be useful,
			* but WITHOUT ANY WARRANTY; without even the implied warranty of
			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
			* GNU General Public License for more details.
			*
			* You should have received a copy of the GNU General Public License
			* along with this program; if not, you may find one here:
			* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
			* or you may search the http://www.gnu.org website for the version 2 license,
			* or you may write to the Free Software Foundation, Inc.,
			* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
			*/


			#include <set>

			#include <io_mgr.h>

			#include <fp_lib_table_lexer.h>
			#include <fp_lib_table.h>


			using namespace FP_LIB_TABLE_T;


			FP_LIB_TABLE::FP_LIB_TABLE( FP_LIB_TABLE* aFallBackTable ) :
			fallBack( aFallBackTable )
			{
			// not copying fall back, simply search aFallBackTable separately
			// if "logicalName not found".
			}


			void FP_LIB_TABLE::Parse( FP_LIB_TABLE_LEXER* in ) throw( IO_ERROR, PARSE_ERROR )
			{
			T tok;

			while( ( tok = in->NextTok() ) != T_RIGHT )
			{
			// (lib (name "LOGICAL")(type "TYPE")(full_uri "FULL_URI")(options "OPTIONS"))

			if( tok == T_EOF )
			in->Expecting( T_RIGHT );

			if( tok != T_LEFT )
			in->Expecting( T_LEFT );

			if( ( tok = in->NextTok() ) != T_fp_lib )
			in->Expecting( T_fp_lib );

			// (name "LOGICAL_NAME")
			in->NeedLEFT();

			if( ( tok = in->NextTok() ) != T_name )
			in->Expecting( T_name );

			in->NeedSYMBOLorNUMBER();

			std::auto_ptr<ROW> row( new ROW( this ) );

			row->SetLogicalName( in->CurText() );

			in->NeedRIGHT();

			// (type "TYPE")
			in->NeedLEFT();

			if( ( tok = in->NextTok() ) != T_type )
			in->Expecting( T_type );

			in->NeedSYMBOLorNUMBER();

			row->SetType( in->CurText() );

			in->NeedRIGHT();

			// (uri "FULL_URI")
			in->NeedLEFT();

			if( ( tok = in->NextTok() ) != T_full_uri )
			in->Expecting( T_full_uri );

			in->NeedSYMBOLorNUMBER();

			row->SetFullURI( in->CurText() );

			in->NeedRIGHT();

			// (options "OPTIONS")
			in->NeedLEFT();

			if( ( tok = in->NextTok() ) != T_options )
			in->Expecting( T_options );

			in->NeedSYMBOLorNUMBER();

			row->SetOptions( in->CurText() );

			in->NeedRIGHT();
			in->NeedRIGHT(); // terminate the (lib..)

			// all logicalNames within this table fragment must be unique, so we do not
			// use doReplace in InsertRow(). However a fallBack table can have a
			// conflicting logicalName and ours will supercede that one since in
			// FindLib() we search this table before any fall back.
			if( !InsertRow( row ) )
			{
			std::string msg;

			msg += '\'';
			msg += row->logicalName;
			msg += '\'';
			msg += " is a duplicate logical footprint library name";
			THROW_IO_ERROR( msg );
			}
			}
			}


			void FP_LIB_TABLE::Format( OUTPUTFORMATTER* out, int nestLevel ) const
			throw( IO_ERROR )
			{
			out->Print( nestLevel, "(fp_lib_table\n" );

			for( ROWS_CITER it = rows.begin(); it != rows.end(); ++it )
			it->second->Format( out, nestLevel+1 );

			out->Print( nestLevel, ")\n" );
			}


			void FP_LIB_TABLE::ROW::Format( OUTPUTFORMATTER* out, int nestLevel ) const
			throw( IO_ERROR )
			{
			out->Print( nestLevel, "(lib (logical %s)(type %s)(full_uri %s)(options %s))\n",
			out->Quotes( logicalName ).c_str(),
			out->Quotes( type ).c_str(),
			out->Quotes( uri ).c_str(),
			out->Quotes( options ).c_str() );
			}


			std::vector<std::string> FP_LIB_TABLE::GetLogicalLibs()
			{
			// Only return unique logical library names. Use std::set::insert() to
			// quietly reject any duplicates, which can happen when encountering a duplicate
			// logical lib name from one of the fall back table(s).

			std::set<std::string> unique;
			std::vector<std::string> ret;
			const FP_LIB_TABLE* cur = this;

			do
			{
			for( ROWS_CITER it = cur->rows.begin(); it!=cur->rows.end(); ++it )
			{
			unique.insert( it->second->logicalName );
			}

			} while( ( cur = cur->fallBack ) != 0 );

			// return a sorted, unique set of logical lib name std::vector<std::string> to caller
			for( std::set<std::string>::const_iterator it = unique.begin(); it!=unique.end(); ++it )
			ret.push_back( *it );

			return ret;
			}


			MODULE* FP_LIB_TABLE::LookupFootprint( const FP_LIB_ID& aFootprintId )
			throw( IO_ERROR )
			{
			PLUGIN* plugin = lookupLib( aFootprintId );

			return plugin->FootprintLoad( wxString( aFootprintId.GetBaseName().c_str() ),
			wxString( aFootprintId.GetLogicalLib().c_str() ) );
			}


			PLUGIN* FP_LIB_TABLE::lookupLib( const FP_LIB_ID& aFootprintId )
			throw( IO_ERROR )
			{
			if( aFootprintId.GetLogicalLib().size() )
			{
			ROW* row = FindRow( aFootprintId.GetLogicalLib() );

			if( !row )
			{
			std::string msg = "lib table contains no logical lib '";
			msg += aFootprintId.GetLogicalLib();
			msg += '\'';
			THROW_IO_ERROR( msg );
			}

			if( !row->lib )
			{
			loadLib( row );
			}

			assert( row->lib ); // fix loadLib() to throw if cannot load

			return row->lib;
			}

			std::string msg = "lookupLib() requires logicalLibName";
			THROW_IO_ERROR( msg );
			}


			void FP_LIB_TABLE::loadLib( ROW* aRow ) throw( IO_ERROR )
			{
			assert( !aRow->lib ); // caller should know better.

			const std::string& type = aRow->GetType();

			if( !type.compare( "dir" ) )
			{
			// @todo Look up plug in here.
			}

			/*
			else if( !type.compare( "schematic" ) )
			{
			// @todo code and load SCHEMATIC_LIB_SOURCE
			}

			else if( !type.compare( "subversion" ) )
			{
			// @todo code and load SVN_LIB_SOURCE
			}

			else if( !type.compare( "http" ) )
			{
			// @todo code and load HTTP_LIB_SOURCE
			}
			*/
			else
			{
			std::string msg = "cannot load unknown footprint library type: '";
			msg += type;
			msg += '\'';
			THROW_IO_ERROR( msg );
			}
			}


			FP_LIB_TABLE::ROW* FP_LIB_TABLE::FindRow( const std::string& aLogicalName ) const
			{
			// this function must be super fast, so therefore should not instantiate
			// anything which would require using the heap. This function is the reason
			// ptr_map<> was used instead of ptr_set<>, which would have required
			// instantiating a ROW just to find a ROW.
			const FP_LIB_TABLE* cur = this;

			do
			{
			ROWS_CITER it = cur->rows.find( aLogicalName );

			if( it != cur->rows.end() )
			{
			// reference: http://myitcorner.com/blog/?p=361
			return (FP_LIB_TABLE::ROW*) it->second; // found
			}

			// not found, search fall back table(s), if any
			} while( ( cur = cur->fallBack ) != 0 );

			return 0; // not found
			}


			bool FP_LIB_TABLE::InsertRow( std::auto_ptr<ROW>& aRow, bool doReplace )
			{
			// this does not need to be super fast.

			ROWS_CITER it = rows.find( aRow->logicalName );

			if( it == rows.end() )
			{
			// be careful here, key is needed because aRow can be
			// release()ed before logicalName is captured.
			const std::string& key = aRow->logicalName;
			rows.insert( key, aRow );
			return true;
			}

			if( doReplace )
			{
			rows.erase( aRow->logicalName );

			// be careful here, key is needed because aRow can be
			// release()ed before logicalName is captured.
			const std::string& key = aRow->logicalName;
			rows.insert( key, aRow );
			return true;
			}

			return false;
			}