KiCad PCB EDA Suite
sch_legacy_plugin.cpp File Reference
#include <ctype.h>
#include <algorithm>
#include <boost/algorithm/string/join.hpp>
#include <wx/mstream.h>
#include <wx/filename.h>
#include <wx/tokenzr.h>
#include <pgm_base.h>
#include <draw_graphic_text.h>
#include <kiway.h>
#include <kicad_string.h>
#include <richio.h>
#include <core/typeinfo.h>
#include <properties.h>
#include <trace_helpers.h>
#include <general.h>
#include <sch_bitmap.h>
#include <sch_bus_entry.h>
#include <sch_component.h>
#include <sch_junction.h>
#include <sch_line.h>
#include <sch_marker.h>
#include <sch_no_connect.h>
#include <sch_text.h>
#include <sch_sheet.h>
#include <bus_alias.h>
#include <sch_legacy_plugin.h>
#include <template_fieldnames.h>
#include <sch_screen.h>
#include <class_libentry.h>
#include <class_library.h>
#include <lib_arc.h>
#include <lib_bezier.h>
#include <lib_circle.h>
#include <lib_field.h>
#include <lib_pin.h>
#include <lib_polyline.h>
#include <lib_rectangle.h>
#include <lib_text.h>
#include <eeschema_id.h>
#include <symbol_lib_table.h>
#include <confirm.h>
#include <tool/selection.h>

Go to the source code of this file.

Classes

class  SCH_LEGACY_PLUGIN_CACHE
 A cache assistant for the part library portion of the SCH_PLUGIN API, and only for the SCH_LEGACY_PLUGIN, so therefore is private to this implementation file, i.e. More...
 

Macros

#define DOCFILE_IDENT   "EESchema-DOCLIB Version 2.0"
 
#define SCH_PARSE_ERROR(text, reader, pos)
 
#define T_STYLE   "style"
 
#define T_COLOR   "rgb"
 
#define T_COLORA   "rgba"
 
#define T_WIDTH   "width"
 

Functions

static bool is_eol (char c)
 
static bool strCompare (const char *aString, const char *aLine, const char **aOutput=NULL)
 Compare aString to the string starting at aLine and advances the character point to the end of String and returns the new pointer position in aOutput if it is not NULL. More...
 
static int parseInt (LINE_READER &aReader, const char *aLine, const char **aOutput=NULL)
 Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointer at aOutput if it is not NULL, just like "man strtol()". More...
 
static uint32_t parseHex (LINE_READER &aReader, const char *aLine, const char **aOutput=NULL)
 Parse an ASCII hex integer string with possible leading whitespace into a long integer and updates the pointer at aOutput if it is not NULL, just like "man strtoll". More...
 
static double parseDouble (LINE_READER &aReader, const char *aLine, const char **aOutput=NULL)
 Parses an ASCII point string with possible leading whitespace into a double precision floating point number and updates the pointer at aOutput if it is not NULL, just like "man strtod". More...
 
static char parseChar (LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=NULL)
 Parse a single ASCII character and updates the pointer at aOutput if it is not NULL. More...
 
static void parseUnquotedString (wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=NULL, bool aCanBeEmpty=false)
 Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL. More...
 
static void parseQuotedString (wxString &aString, LINE_READER &aReader, const char *aCurrentToken, const char **aNextToken=NULL, bool aCanBeEmpty=false)
 Parse an quoted ASCII utf8 and updates the pointer at aOutput if it is not NULL. More...
 

Variables

const char * delims = " \t\r\n"
 

Macro Definition Documentation

◆ DOCFILE_IDENT

#define DOCFILE_IDENT   "EESchema-DOCLIB Version 2.0"

Definition at line 71 of file sch_legacy_plugin.cpp.

◆ SCH_PARSE_ERROR

#define SCH_PARSE_ERROR (   text,
  reader,
  pos 
)
Value:
THROW_PARSE_ERROR( text, reader.GetSource(), reader.Line(), \
reader.LineNumber(), pos - reader.Line() )
#define THROW_PARSE_ERROR(aProblem, aSource, aInputLine, aLineNumber, aByteIndex)

Definition at line 73 of file sch_legacy_plugin.cpp.

◆ T_COLOR

#define T_COLOR   "rgb"

Definition at line 83 of file sch_legacy_plugin.cpp.

◆ T_COLORA

#define T_COLORA   "rgba"

Definition at line 84 of file sch_legacy_plugin.cpp.

◆ T_STYLE

#define T_STYLE   "style"

Definition at line 82 of file sch_legacy_plugin.cpp.

◆ T_WIDTH

#define T_WIDTH   "width"

Definition at line 85 of file sch_legacy_plugin.cpp.

Function Documentation

◆ is_eol()

static bool is_eol ( char  c)
static

Definition at line 88 of file sch_legacy_plugin.cpp.

89 {
90  // The default file eol character used internally by KiCad.
91  // |
92  // | Possible eol if someone edited the file by hand on certain platforms.
93  // | |
94  // | | May have gone past eol with strtok().
95  // | | |
96  if( c == '\n' || c == '\r' || c == 0 )
97  return true;
98 
99  return false;
100 }

Referenced by SCH_LEGACY_PLUGIN_CACHE::loadText(), and SCH_LEGACY_PLUGIN::loadWire().

◆ parseChar()

static char parseChar ( LINE_READER aReader,
const char *  aCurrentToken,
const char **  aNextToken = NULL 
)
static

Parse a single ASCII character and updates the pointer at aOutput if it is not NULL.

Parameters
aReader- The line reader used to generate exception throw information.
aCurrentToken- A pointer the current position in a string.
aNextToken- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
Returns
A valid ASCII character.
Exceptions
IO_ERRORon an unexpected end of line.
PARSE_ERRORif the parsed token is not a a single character token.

Definition at line 278 of file sch_legacy_plugin.cpp.

280 {
281  while( *aCurrentToken && isspace( *aCurrentToken ) )
282  aCurrentToken++;
283 
284  if( !*aCurrentToken )
285  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
286 
287  if( !isspace( *( aCurrentToken + 1 ) ) )
288  SCH_PARSE_ERROR( "expected single character token", aReader, aCurrentToken );
289 
290  if( aNextToken )
291  {
292  const char* next = aCurrentToken + 2;
293 
294  while( *next && isspace( *next ) )
295  next++;
296 
297  *aNextToken = next;
298  }
299 
300  return *aCurrentToken;
301 }
CITER next(CITER it)
Definition: ptree.cpp:130
#define SCH_PARSE_ERROR(text, reader, pos)

References next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN_CACHE::loadField(), SCH_LEGACY_PLUGIN::loadSheet(), SCH_LEGACY_PLUGIN_CACHE::loadText(), and SCH_LEGACY_PLUGIN_CACHE::parseFillMode().

◆ parseDouble()

static double parseDouble ( LINE_READER aReader,
const char *  aLine,
const char **  aOutput = NULL 
)
static

Parses an ASCII point string with possible leading whitespace into a double precision floating point number and updates the pointer at aOutput if it is not NULL, just like "man strtod".

Parameters
aReader- The line reader used to generate exception throw information.
aLine- A pointer the current position in a string.
aOutput- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
Returns
A valid double value.
Exceptions
IO_ERRORon an unexpected end of line.
PARSE_ERRORif the parsed token is not a valid integer.

Definition at line 237 of file sch_legacy_plugin.cpp.

239 {
240  if( !*aLine )
241  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );
242 
243  // Clear errno before calling strtod() in case some other crt call set it.
244  errno = 0;
245 
246  double retv = strtod( aLine, (char**) aOutput );
247 
248  // Make sure no error occurred when calling strtod().
249  if( errno == ERANGE )
250  SCH_PARSE_ERROR( "invalid floating point number", aReader, aLine );
251 
252  // strtod does not strip off whitespace before the next token.
253  if( aOutput )
254  {
255  const char* next = *aOutput;
256 
257  while( *next && isspace( *next ) )
258  next++;
259 
260  *aOutput = next;
261  }
262 
263  return retv;
264 }
CITER next(CITER it)
Definition: ptree.cpp:130
#define SCH_PARSE_ERROR(text, reader, pos)

References next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN::loadBitmap(), PCB_PARSER::parse3DModel(), PCB_PARSER::parseD_PAD(), PCB_PARSER::parseDRAWSEGMENT(), PCB_PARSER::parseEDGE_MODULE(), PCB_PARSER::parseMODULE_unchecked(), PCB_PARSER::parsePAGE_INFO(), PCB_PARSER::parseSetup(), PCB_PARSER::parseTEXTE_MODULE(), PCB_PARSER::parseTEXTE_PCB(), and PCB_PARSER::parseZONE_CONTAINER().

◆ parseHex()

static uint32_t parseHex ( LINE_READER aReader,
const char *  aLine,
const char **  aOutput = NULL 
)
static

Parse an ASCII hex integer string with possible leading whitespace into a long integer and updates the pointer at aOutput if it is not NULL, just like "man strtoll".

Parameters
aReader- The line reader used to generate exception throw information.
aLine- A pointer the current position in a string.
aOutput- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
Returns
A valid uint32_t value.
Exceptions
IO_ERRORon an unexpected end of line.
PARSE_ERRORif the parsed token is not a valid integer.

Definition at line 191 of file sch_legacy_plugin.cpp.

193 {
194  if( !*aLine )
195  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );
196 
197  // Due to some issues between some files created by a 64 bits version and those
198  // created by a 32 bits version, we use here a temporary at least 64 bits storage:
199  unsigned long long retv;
200 
201  // Clear errno before calling strtoull() in case some other crt call set it.
202  errno = 0;
203  retv = strtoull( aLine, (char**) aOutput, 16 );
204 
205  // Make sure no error occurred when calling strtoull().
206  if( errno == ERANGE )
207  SCH_PARSE_ERROR( "invalid hexadecimal number", aReader, aLine );
208 
209  // Strip off whitespace before the next token.
210  if( aOutput )
211  {
212  const char* next = *aOutput;
213 
214  while( *next && isspace( *next ) )
215  next++;
216 
217  *aOutput = next;
218  }
219 
220  return (uint32_t)retv;
221 }
CITER next(CITER it)
Definition: ptree.cpp:130
#define SCH_PARSE_ERROR(text, reader, pos)

References next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN::loadSheet(), PCB_PARSER::parseDIMENSION(), PCB_PARSER::parseDRAWSEGMENT(), PCB_PARSER::parseEDGE_MODULE(), PCB_PARSER::parseMODULE_unchecked(), PCB_PARSER::parsePCB_TARGET(), PCB_PARSER::parseSetup(), PCB_PARSER::parseTEXTE_PCB(), PCB_PARSER::parseTRACK(), PCB_PARSER::parseVIA(), and PCB_PARSER::parseZONE_CONTAINER().

◆ parseInt()

static int parseInt ( LINE_READER aReader,
const char *  aLine,
const char **  aOutput = NULL 
)
static

Parse an ASCII integer string with possible leading whitespace into an integer and updates the pointer at aOutput if it is not NULL, just like "man strtol()".

Parameters
aReader- The line reader used to generate exception throw information.
aLine- A pointer the current position in a string.
aOutput- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
Returns
A valid integer value.
Exceptions
AnIO_ERROR on an unexpected end of line.
APARSE_ERROR if the parsed token is not a valid integer.

Definition at line 149 of file sch_legacy_plugin.cpp.

150 {
151  if( !*aLine )
152  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aLine );
153 
154  // Clear errno before calling strtol() in case some other crt call set it.
155  errno = 0;
156 
157  long retv = strtol( aLine, (char**) aOutput, 10 );
158 
159  // Make sure no error occurred when calling strtol().
160  if( errno == ERANGE )
161  SCH_PARSE_ERROR( "invalid integer value", aReader, aLine );
162 
163  // strtol does not strip off whitespace before the next token.
164  if( aOutput )
165  {
166  const char* next = *aOutput;
167 
168  while( *next && isspace( *next ) )
169  next++;
170 
171  *aOutput = next;
172  }
173 
174  return (int) retv;
175 }
CITER next(CITER it)
Definition: ptree.cpp:130
#define SCH_PARSE_ERROR(text, reader, pos)

References next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN_CACHE::Load(), SCH_LEGACY_PLUGIN_CACHE::loadArc(), SCH_LEGACY_PLUGIN_CACHE::loadBezier(), SCH_LEGACY_PLUGIN::loadBitmap(), SCH_LEGACY_PLUGIN::loadBusEntry(), SCH_LEGACY_PLUGIN_CACHE::loadCircle(), SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN_CACHE::loadField(), SCH_LEGACY_PLUGIN::loadHeader(), SCH_LEGACY_PLUGIN::loadJunction(), SCH_LEGACY_PLUGIN::loadNoConnect(), SCH_LEGACY_PLUGIN::loadPageSettings(), SCH_LEGACY_PLUGIN_CACHE::loadPolyLine(), SCH_LEGACY_PLUGIN_CACHE::loadRectangle(), SCH_LEGACY_PLUGIN::loadSheet(), SCH_LEGACY_PLUGIN::loadText(), SCH_LEGACY_PLUGIN_CACHE::loadText(), and SCH_LEGACY_PLUGIN::loadWire().

◆ parseQuotedString()

static void parseQuotedString ( wxString &  aString,
LINE_READER aReader,
const char *  aCurrentToken,
const char **  aNextToken = NULL,
bool  aCanBeEmpty = false 
)
static

Parse an quoted ASCII utf8 and updates the pointer at aOutput if it is not NULL.

The parsed string must be contained within a single line. There are no multi-line quoted strings in the legacy schematic file format.

Parameters
aString- A reference to the parsed string.
aReader- The line reader used to generate exception throw information.
aCurrentToken- A pointer the current position in a string.
aNextToken- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
aCanBeEmpty- True if the parsed string is optional. False if it is mandatory.
Exceptions
IO_ERRORon an unexpected end of line.
PARSE_ERRORif the aCanBeEmpty is false and no string was parsed.

Definition at line 380 of file sch_legacy_plugin.cpp.

383 {
384  if( !*aCurrentToken )
385  {
386  if( aCanBeEmpty )
387  return;
388  else
389  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
390  }
391 
392  const char* tmp = aCurrentToken;
393 
394  while( *tmp && isspace( *tmp ) )
395  tmp++;
396 
397  if( !*tmp )
398  {
399  if( aCanBeEmpty )
400  return;
401  else
402  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
403  }
404 
405  // Verify opening quote.
406  if( *tmp != '"' )
407  SCH_PARSE_ERROR( "expecting opening quote", aReader, aCurrentToken );
408 
409  tmp++;
410 
411  std::string utf8; // utf8 without escapes and quotes.
412 
413  // Fetch everything up to closing quote.
414  while( *tmp )
415  {
416  if( *tmp == '\\' )
417  {
418  tmp++;
419 
420  if( !*tmp )
421  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
422 
423  // Do not copy the escape byte if it is followed by \ or "
424  if( *tmp != '"' && *tmp != '\\' )
425  utf8 += '\\';
426 
427  utf8 += *tmp;
428  }
429  else if( *tmp == '"' ) // Closing double quote.
430  {
431  break;
432  }
433  else
434  {
435  utf8 += *tmp;
436  }
437 
438  tmp++;
439  }
440 
441  aString = FROM_UTF8( utf8.c_str() );
442 
443  if( aString.IsEmpty() && !aCanBeEmpty )
444  SCH_PARSE_ERROR( "expected quoted string", aReader, aCurrentToken );
445 
446  if( *tmp && *tmp != '"' )
447  SCH_PARSE_ERROR( "no closing quote for string found", aReader, tmp );
448 
449  // Move past the closing quote.
450  tmp++;
451 
452  if( aNextToken )
453  {
454  const char* next = tmp;
455 
456  while( *next && *next == ' ' )
457  next++;
458 
459  *aNextToken = next;
460  }
461 }
CITER next(CITER it)
Definition: ptree.cpp:130
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:61
#define SCH_PARSE_ERROR(text, reader, pos)

References FROM_UTF8(), next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN_CACHE::loadField(), SCH_LEGACY_PLUGIN::loadPageSettings(), SCH_LEGACY_PLUGIN::loadSheet(), and SCH_LEGACY_PLUGIN_CACHE::loadText().

◆ parseUnquotedString()

static void parseUnquotedString ( wxString &  aString,
LINE_READER aReader,
const char *  aCurrentToken,
const char **  aNextToken = NULL,
bool  aCanBeEmpty = false 
)
static

Parse an unquoted utf8 string and updates the pointer at aOutput if it is not NULL.

The parsed string must be a continuous string with no white space.

Parameters
aString- A reference to the parsed string.
aReader- The line reader used to generate exception throw information.
aCurrentToken- A pointer the current position in a string.
aNextToken- The pointer to a string pointer to copy the string pointer position when the parsing is complete.
aCanBeEmpty- True if the parsed string is optional. False if it is mandatory.
Exceptions
IO_ERRORon an unexpected end of line.
PARSE_ERRORif the aCanBeEmpty is false and no string was parsed.

Definition at line 318 of file sch_legacy_plugin.cpp.

321 {
322  if( !*aCurrentToken )
323  {
324  if( aCanBeEmpty )
325  return;
326  else
327  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
328  }
329 
330  const char* tmp = aCurrentToken;
331 
332  while( *tmp && isspace( *tmp ) )
333  tmp++;
334 
335  if( !*tmp )
336  {
337  if( aCanBeEmpty )
338  return;
339  else
340  SCH_PARSE_ERROR( _( "unexpected end of line" ), aReader, aCurrentToken );
341  }
342 
343  std::string utf8;
344 
345  while( *tmp && !isspace( *tmp ) )
346  utf8 += *tmp++;
347 
348  aString = FROM_UTF8( utf8.c_str() );
349 
350  if( aString.IsEmpty() && !aCanBeEmpty )
351  SCH_PARSE_ERROR( _( "expected unquoted string" ), aReader, aCurrentToken );
352 
353  if( aNextToken )
354  {
355  const char* next = tmp;
356 
357  while( *next && isspace( *next ) )
358  next++;
359 
360  *aNextToken = next;
361  }
362 }
CITER next(CITER it)
Definition: ptree.cpp:130
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:61
#define SCH_PARSE_ERROR(text, reader, pos)

References FROM_UTF8(), next(), and SCH_PARSE_ERROR.

Referenced by SCH_LEGACY_PLUGIN::loadBusAlias(), SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN_CACHE::loadField(), SCH_LEGACY_PLUGIN_CACHE::loadFootprintFilters(), SCH_LEGACY_PLUGIN::loadJunction(), SCH_LEGACY_PLUGIN::loadNoConnect(), SCH_LEGACY_PLUGIN::loadPageSettings(), SCH_LEGACY_PLUGIN_CACHE::loadText(), and SCH_LEGACY_PLUGIN::loadWire().

◆ strCompare()

static bool strCompare ( const char *  aString,
const char *  aLine,
const char **  aOutput = NULL 
)
static

Compare aString to the string starting at aLine and advances the character point to the end of String and returns the new pointer position in aOutput if it is not NULL.

Parameters
aString- A pointer to the string to compare.
aLine- A pointer to string to begin the comparison.
aOutput- A pointer to a string pointer to the end of the comparison if not NULL.
Returns
true if aString was found starting at aLine. Otherwise false.

Definition at line 112 of file sch_legacy_plugin.cpp.

113 {
114  size_t len = strlen( aString );
115  bool retv = ( strncasecmp( aLine, aString, len ) == 0 ) &&
116  ( isspace( aLine[ len ] ) || aLine[ len ] == 0 );
117 
118  if( retv && aOutput )
119  {
120  const char* tmp = aLine;
121 
122  // Move past the end of the token.
123  tmp += len;
124 
125  // Move to the beginning of the next token.
126  while( *tmp && isspace( *tmp ) )
127  tmp++;
128 
129  *aOutput = tmp;
130  }
131 
132  return retv;
133 }

Referenced by SCH_LEGACY_PLUGIN_CACHE::Load(), SCH_LEGACY_PLUGIN_CACHE::loadAliases(), SCH_LEGACY_PLUGIN_CACHE::loadArc(), SCH_LEGACY_PLUGIN_CACHE::loadBezier(), SCH_LEGACY_PLUGIN::loadBitmap(), SCH_LEGACY_PLUGIN::loadBusAlias(), SCH_LEGACY_PLUGIN::loadBusEntry(), SCH_LEGACY_PLUGIN_CACHE::loadCircle(), SCH_LEGACY_PLUGIN::loadComponent(), SCH_LEGACY_PLUGIN::LoadContent(), SCH_LEGACY_PLUGIN_CACHE::loadDocs(), SCH_LEGACY_PLUGIN_CACHE::loadDrawEntries(), SCH_LEGACY_PLUGIN::loadFile(), SCH_LEGACY_PLUGIN_CACHE::loadFootprintFilters(), SCH_LEGACY_PLUGIN::loadHeader(), SCH_LEGACY_PLUGIN_CACHE::loadHeader(), SCH_LEGACY_PLUGIN::loadJunction(), SCH_LEGACY_PLUGIN::loadNoConnect(), SCH_LEGACY_PLUGIN::loadPageSettings(), SCH_LEGACY_PLUGIN_CACHE::LoadPart(), SCH_LEGACY_PLUGIN_CACHE::loadPin(), SCH_LEGACY_PLUGIN_CACHE::loadPolyLine(), SCH_LEGACY_PLUGIN_CACHE::loadRectangle(), SCH_LEGACY_PLUGIN::loadSheet(), SCH_LEGACY_PLUGIN::loadText(), SCH_LEGACY_PLUGIN_CACHE::loadText(), and SCH_LEGACY_PLUGIN::loadWire().

Variable Documentation

◆ delims

const char* delims = " \t\r\n"

Definition at line 79 of file sch_legacy_plugin.cpp.