haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't use std::string for things with wxString APIs. 

It's too bug-prone.

Fixes https://gitlab.com/kicad/code/kicad/issues/13380
This commit is contained in:
Jeff Young 2023-01-05 14:16:06 +00:00
parent 3b021d98be
commit 7af718f1a5
8 changed files with 80 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
eeschema/dialogs/dialog_lib_symbol_properties.cpp
View File

@ -184,7 +184,7 @@ bool DIALOG_LIB_SYMBOL_PROPERTIES::TransferDataToWindow()
m_OptionPower->SetValue( m_libEntry->IsPower() );
#ifdef KICAD_SPICE
LIB_FIELD* simEnableField = m_libEntry->FindField( SIM_MODEL::ENABLE_FIELD );
LIB_FIELD* simEnableField = m_libEntry->FindField( SIM_ENABLE_FIELD );
m_excludeFromSim->SetValue( simEnableField && simEnableField->GetText() == wxT( "0" ) );
#endif
@ -237,7 +237,7 @@ void DIALOG_LIB_SYMBOL_PROPERTIES::OnExcludeFromSimulation( wxCommandEvent& even
for( int ii = MANDATORY_FIELDS; ii < m_grid->GetNumberRows(); ++ii )
{
if( m_grid->GetCellValue( ii, FDC_NAME ) == SIM_MODEL::ENABLE_FIELD )
if( m_grid->GetCellValue( ii, FDC_NAME ) == SIM_ENABLE_FIELD )
simEnableFieldRow = ii;
}

10
eeschema/dialogs/dialog_sim_model.cpp
View File

@ -147,19 +147,19 @@ bool DIALOG_SIM_MODEL<T_symbol, T_field>::TransferDataToWindow()
if( SIM_MODEL::InferSimModel( m_symbol, &m_fields, false, SIM_VALUE_GRAMMAR::NOTATION::SI,
&deviceType, &modelType, &modelParams, &pinMap ) )
{
m_fields.emplace_back( &m_symbol, -1, SIM_MODEL::DEVICE_TYPE_FIELD );
m_fields.emplace_back( &m_symbol, -1, SIM_DEVICE_TYPE_FIELD );
m_fields.back().SetText( deviceType );
if( !modelType.IsEmpty() )
{
m_fields.emplace_back( &m_symbol, -1, SIM_MODEL::TYPE_FIELD );
m_fields.emplace_back( &m_symbol, -1, SIM_TYPE_FIELD );
m_fields.back().SetText( modelType );
}
m_fields.emplace_back( &m_symbol, -1, SIM_MODEL::PARAMS_FIELD );
m_fields.emplace_back( &m_symbol, -1, SIM_PARAMS_FIELD );
m_fields.back().SetText( modelParams );
m_fields.emplace_back( &m_symbol, -1, SIM_MODEL::PINS_FIELD );
m_fields.emplace_back( &m_symbol, -1, SIM_PINS_FIELD );
m_fields.back().SetText( pinMap );
storeInValue = true;
@ -359,7 +359,7 @@ void DIALOG_SIM_MODEL<T_symbol, T_field>::updateWidgets()
updateModelCodeTab();
updatePinAssignments();
std::string ref = SIM_MODEL::GetFieldValue( &m_fields, SIM_MODEL::REFERENCE_FIELD );
std::string ref = SIM_MODEL::GetFieldValue( &m_fields, SIM_REFERENCE_FIELD );
m_modelPanel->Layout();
m_pinAssignmentsPanel->Layout();

7
eeschema/dialogs/dialog_symbol_properties.cpp
View File

@ -515,7 +515,7 @@ bool DIALOG_SYMBOL_PROPERTIES::TransferDataToWindow()
}
#ifdef KICAD_SPICE
m_cbExcludeFromSim->SetValue( m_symbol->GetFieldText( SIM_MODEL::ENABLE_FIELD ) == "0" );
m_cbExcludeFromSim->SetValue( m_symbol->GetFieldText( SIM_ENABLE_FIELD ) == "0" );
#endif
m_cbExcludeFromBom->SetValue( !m_symbol->GetIncludeInBom() );
m_cbExcludeFromBoard->SetValue( !m_symbol->GetIncludeOnBoard() );
@ -545,7 +545,7 @@ void DIALOG_SYMBOL_PROPERTIES::OnExcludeFromSimulation( wxCommandEvent& event )
for( int ii = MANDATORY_FIELDS; ii < m_fieldsGrid->GetNumberRows(); ++ii )
{
if( m_fieldsGrid->GetCellValue( ii, FDC_NAME ) == SIM_MODEL::ENABLE_FIELD )
if( m_fieldsGrid->GetCellValue( ii, FDC_NAME ) == SIM_ENABLE_FIELD )
simEnableFieldRow = ii;
}
@ -554,8 +554,7 @@ void DIALOG_SYMBOL_PROPERTIES::OnExcludeFromSimulation( wxCommandEvent& event )
if( simEnableFieldRow == -1 )
{
simEnableFieldRow = (int) m_fields->size();
m_fields->emplace_back( VECTOR2I( 0, 0 ), simEnableFieldRow, m_symbol,
SIM_MODEL::ENABLE_FIELD );
m_fields->emplace_back( VECTOR2I( 0, 0 ), simEnableFieldRow, m_symbol, SIM_ENABLE_FIELD );
// notify the grid
wxGridTableMessage msg( m_fields, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, 1 );

10
eeschema/netlist_exporters/netlist_exporter_spice.cpp
View File

@ -215,7 +215,7 @@ bool NETLIST_EXPORTER_SPICE::ReadSchematicAndLibraries( unsigned aNetlistOptions
{
SCH_SYMBOL* symbol = findNextSymbol( item, &sheet );
if( !symbol || symbol->GetFieldText( SIM_MODEL::ENABLE_FIELD ) == wxT( "0" ) )
if( !symbol || symbol->GetFieldText( SIM_ENABLE_FIELD ) == wxT( "0" ) )
continue;
CreatePinList( symbol, &sheet, true );
@ -243,19 +243,19 @@ bool NETLIST_EXPORTER_SPICE::ReadSchematicAndLibraries( unsigned aNetlistOptions
SIM_VALUE_GRAMMAR::NOTATION::SPICE, &deviceType,
&modelType, &modelParams, &pinMap ) )
{
spiceItem.fields.emplace_back( symbol, -1, SIM_MODEL::DEVICE_TYPE_FIELD );
spiceItem.fields.emplace_back( symbol, -1, SIM_DEVICE_TYPE_FIELD );
spiceItem.fields.back().SetText( deviceType );
if( !modelType.IsEmpty() )
{
spiceItem.fields.emplace_back( symbol, -1, SIM_MODEL::TYPE_FIELD );
spiceItem.fields.emplace_back( symbol, -1, SIM_TYPE_FIELD );
spiceItem.fields.back().SetText( modelType );
}
spiceItem.fields.emplace_back( symbol, -1, SIM_MODEL::PARAMS_FIELD );
spiceItem.fields.emplace_back( symbol, -1, SIM_PARAMS_FIELD );
spiceItem.fields.back().SetText( modelParams );
spiceItem.fields.emplace_back( symbol, -1, SIM_MODEL::PINS_FIELD );
spiceItem.fields.emplace_back( symbol, -1, SIM_PINS_FIELD );
spiceItem.fields.back().SetText( pinMap );
}

8
eeschema/sim/sim_lib_mgr.cpp
View File

@ -217,19 +217,19 @@ SIM_LIBRARY::MODEL SIM_LIB_MGR::CreateModel( const SCH_SHEET_PATH* aSheetPath, S
if( SIM_MODEL::InferSimModel( aSymbol, &fields, true, SIM_VALUE_GRAMMAR::NOTATION::SI,
&deviceType, &modelType, &modelParams, &pinMap ) )
{
fields.emplace_back( &aSymbol, -1, SIM_MODEL::DEVICE_TYPE_FIELD );
fields.emplace_back( &aSymbol, -1, SIM_DEVICE_TYPE_FIELD );
fields.back().SetText( deviceType );
if( !modelType.IsEmpty() )
{
fields.emplace_back( &aSymbol, -1, SIM_MODEL::TYPE_FIELD );
fields.emplace_back( &aSymbol, -1, SIM_TYPE_FIELD );
fields.back().SetText( modelType );
}
fields.emplace_back( &aSymbol, -1, SIM_MODEL::PARAMS_FIELD );
fields.emplace_back( &aSymbol, -1, SIM_PARAMS_FIELD );
fields.back().SetText( modelParams );
fields.emplace_back( &aSymbol, -1, SIM_MODEL::PINS_FIELD );
fields.emplace_back( &aSymbol, -1, SIM_PINS_FIELD );
fields.back().SetText( pinMap );
storeInValue = true;

88
eeschema/sim/sim_model.cpp
View File

@ -367,8 +367,8 @@ template TYPE SIM_MODEL::ReadTypeFromFields( const std::vector<LIB_FIELD>& aFiel
template <typename T>
TYPE SIM_MODEL::ReadTypeFromFields( const std::vector<T>& aFields )
{
std::string deviceTypeFieldValue = GetFieldValue( &aFields, DEVICE_TYPE_FIELD );
std::string typeFieldValue = GetFieldValue( &aFields, TYPE_FIELD );
std::string deviceTypeFieldValue = GetFieldValue( &aFields, SIM_DEVICE_TYPE_FIELD );
std::string typeFieldValue = GetFieldValue( &aFields, SIM_TYPE_FIELD );
if( deviceTypeFieldValue != "" )
{
@ -575,17 +575,17 @@ std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( const std::vector<T>& aFields,
// Just because we can't parse it doesn't mean that a SPICE interpreter can't. Fall
// back to a raw spice code model.
std::string modelData = GetFieldValue( &aFields, PARAMS_FIELD );
std::string modelData = GetFieldValue( &aFields, SIM_PARAMS_FIELD );
if( modelData.empty() )
modelData = GetFieldValue( &aFields, VALUE_FIELD );
modelData = GetFieldValue( &aFields, SIM_VALUE_FIELD );
model = std::make_unique<SIM_MODEL_RAW_SPICE>( modelData );
try
{
model->createPins( aPins );
model->m_serializer->ParsePins( GetFieldValue( &aFields, PINS_FIELD ) );
model->m_serializer->ParsePins( GetFieldValue( &aFields, SIM_PINS_FIELD ) );
}
catch( const IO_ERROR& err )
{
@ -609,7 +609,7 @@ template std::unique_ptr<SIM_MODEL> SIM_MODEL::Create( const std::vector<LIB_FIE
template <typename T>
std::string SIM_MODEL::GetFieldValue( const std::vector<T>* aFields, const std::string& aFieldName,
std::string SIM_MODEL::GetFieldValue( const std::vector<T>* aFields, const wxString& aFieldName,
bool aResolve )
{
static_assert( std::is_same<T, SCH_FIELD>::value || std::is_same<T, LIB_FIELD>::value );
@ -629,15 +629,15 @@ std::string SIM_MODEL::GetFieldValue( const std::vector<T>* aFields, const std::
// This specialization is used when no fields are passed.
template <>
std::string SIM_MODEL::GetFieldValue( const std::vector<void>* aFields,
const std::string& aFieldName, bool aResolve )
std::string SIM_MODEL::GetFieldValue( const std::vector<void>* aFields, const wxString& aFieldName,
bool aResolve )
{
return "";
}
template <typename T>
void SIM_MODEL::SetFieldValue( std::vector<T>& aFields, const std::string& aFieldName,
void SIM_MODEL::SetFieldValue( std::vector<T>& aFields, const wxString& aFieldName,
const std::string& aValue )
{
static_assert( std::is_same<T, SCH_FIELD>::value || std::is_same<T, LIB_FIELD>::value );
@ -678,10 +678,10 @@ void SIM_MODEL::SetFieldValue( std::vector<T>& aFields, const std::string& aFiel
template void SIM_MODEL::SetFieldValue<SCH_FIELD>( std::vector<SCH_FIELD>& aFields,
const std::string& aFieldName,
const wxString& aFieldName,
const std::string& aValue );
template void SIM_MODEL::SetFieldValue<LIB_FIELD>( std::vector<LIB_FIELD>& aFields,
const std::string& aFieldName,
const wxString& aFieldName,
const std::string& aValue );
SIM_MODEL::~SIM_MODEL() = default;
@ -1032,12 +1032,12 @@ void SIM_MODEL::doReadDataFields( const std::vector<T>* aFields,
bool diffMode = GetFieldValue( aFields, SIM_LIBRARY_KIBIS::DIFF_FIELD ) == "1";
SwitchSingleEndedDiff( diffMode );
m_serializer->ParseEnable( GetFieldValue( aFields, ENABLE_FIELD ) );
m_serializer->ParseEnable( GetFieldValue( aFields, SIM_ENABLE_FIELD ) );
createPins( aPins );
m_serializer->ParsePins( GetFieldValue( aFields, PINS_FIELD ) );
m_serializer->ParsePins( GetFieldValue( aFields, SIM_PINS_FIELD ) );
std::string paramsField = GetFieldValue( aFields, PARAMS_FIELD );
std::string paramsField = GetFieldValue( aFields, SIM_PARAMS_FIELD );
if( !m_serializer->ParseParams( paramsField ) )
{
@ -1047,7 +1047,7 @@ void SIM_MODEL::doReadDataFields( const std::vector<T>* aFields,
// but don't be belligerent about it.
try
{
m_serializer->ParseValue( GetFieldValue( aFields, VALUE_FIELD ) );
m_serializer->ParseValue( GetFieldValue( aFields, SIM_VALUE_FIELD ) );
}
catch( ... )
{
@ -1059,16 +1059,16 @@ void SIM_MODEL::doReadDataFields( const std::vector<T>* aFields,
template <typename T>
void SIM_MODEL::doWriteFields( std::vector<T>& aFields ) const
{
SetFieldValue( aFields, DEVICE_TYPE_FIELD, m_serializer->GenerateDevice() );
SetFieldValue( aFields, TYPE_FIELD, m_serializer->GenerateType() );
SetFieldValue( aFields, SIM_DEVICE_TYPE_FIELD, m_serializer->GenerateDevice() );
SetFieldValue( aFields, SIM_TYPE_FIELD, m_serializer->GenerateType() );
SetFieldValue( aFields, ENABLE_FIELD, m_serializer->GenerateEnable() );
SetFieldValue( aFields, PINS_FIELD, m_serializer->GeneratePins() );
SetFieldValue( aFields, SIM_ENABLE_FIELD, m_serializer->GenerateEnable() );
SetFieldValue( aFields, SIM_PINS_FIELD, m_serializer->GeneratePins() );
SetFieldValue( aFields, PARAMS_FIELD, m_serializer->GenerateParams() );
SetFieldValue( aFields, SIM_PARAMS_FIELD, m_serializer->GenerateParams() );
if( IsStoredInValue() )
SetFieldValue( aFields, VALUE_FIELD, m_serializer->GenerateValue() );
SetFieldValue( aFields, SIM_VALUE_FIELD, m_serializer->GenerateValue() );
}
@ -1184,13 +1184,13 @@ bool SIM_MODEL::InferSimModel( T_symbol& aSymbol, std::vector<T_field>* aFields,
};
wxString prefix = aSymbol.GetPrefix();
wxString value = GetFieldValue( aFields, VALUE_FIELD, aResolve );
wxString value = GetFieldValue( aFields, SIM_VALUE_FIELD, aResolve );
std::vector<LIB_PIN*> pins = aSymbol.GetAllLibPins();
*aDeviceType = GetFieldValue( aFields, DEVICE_TYPE_FIELD, aResolve );
*aModelType = GetFieldValue( aFields, TYPE_FIELD, aResolve );
*aModelParams = GetFieldValue( aFields, PARAMS_FIELD, aResolve );
*aPinMap = GetFieldValue( aFields, PINS_FIELD, aResolve );
*aDeviceType = GetFieldValue( aFields, SIM_DEVICE_TYPE_FIELD, aResolve );
*aModelType = GetFieldValue( aFields, SIM_TYPE_FIELD, aResolve );
*aModelParams = GetFieldValue( aFields, SIM_PARAMS_FIELD, aResolve );
*aPinMap = GetFieldValue( aFields, SIM_PINS_FIELD, aResolve );
if( pins.size() != 2 )
return false;
@ -1341,10 +1341,10 @@ template bool SIM_MODEL::InferSimModel<LIB_SYMBOL, LIB_FIELD>( LIB_SYMBOL& aSymb
template <typename T_symbol, typename T_field>
void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
{
if( aSymbol.FindField( SIM_MODEL::DEVICE_TYPE_FIELD )
|| aSymbol.FindField( SIM_MODEL::TYPE_FIELD )
|| aSymbol.FindField( SIM_MODEL::PINS_FIELD )
|| aSymbol.FindField( SIM_MODEL::PARAMS_FIELD ) )
if( aSymbol.FindField( SIM_DEVICE_TYPE_FIELD )
|| aSymbol.FindField( SIM_TYPE_FIELD )
|| aSymbol.FindField( SIM_PINS_FIELD )
|| aSymbol.FindField( SIM_PARAMS_FIELD ) )
{
// Has a V7 model field -- skip.
return;
@ -1494,7 +1494,7 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
|| netlistEnabled.StartsWith( wxT( "n" ) )
|| netlistEnabled.StartsWith( wxT( "f" ) ) )
{
netlistEnabledField->SetName( SIM_MODEL::ENABLE_FIELD );
netlistEnabledField->SetName( SIM_ENABLE_FIELD );
netlistEnabledField->SetText( wxT( "0" ) );
}
else
@ -1515,12 +1515,12 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
if( T_field* legacyType = aSymbol.FindField( wxT( "Sim_Type" ) ) )
{
legacyType->SetName( SIM_MODEL::TYPE_FIELD );
legacyType->SetName( SIM_TYPE_FIELD );
}
if( T_field* legacyDevice = aSymbol.FindField( wxT( "Sim_Device" ) ) )
{
legacyDevice->SetName( SIM_MODEL::DEVICE_TYPE_FIELD );
legacyDevice->SetName( SIM_DEVICE_TYPE_FIELD );
}
if( T_field* legacyPins = aSymbol.FindField( wxT( "Sim_Pins" ) ) )
@ -1563,13 +1563,13 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
}
}
legacyPins->SetName( SIM_MODEL::PINS_FIELD );
legacyPins->SetName( SIM_PINS_FIELD );
legacyPins->SetText( pinMap );
}
if( T_field* legacyParams = aSymbol.FindField( wxT( "Sim_Params" ) ) )
{
legacyParams->SetName( SIM_MODEL::PARAMS_FIELD );
legacyParams->SetName( SIM_PARAMS_FIELD );
}
return;
@ -1680,16 +1680,16 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
if( libraryModel )
{
T_field libraryField = spiceLibInfo.CreateField( &aSymbol, SIM_MODEL::LIBRARY_FIELD );
T_field libraryField = spiceLibInfo.CreateField( &aSymbol, SIM_LIBRARY_FIELD );
aSymbol.AddField( libraryField );
T_field nameField = spiceModelInfo.CreateField( &aSymbol, SIM_MODEL::NAME_FIELD );
T_field nameField = spiceModelInfo.CreateField( &aSymbol, SIM_NAME_FIELD );
aSymbol.AddField( nameField );
// Don't write a paramsField unless we actually have overrides
if( !spiceParamsInfo.IsEmpty() )
{
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_MODEL::PARAMS_FIELD );
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
aSymbol.AddField( paramsField );
}
@ -1703,15 +1703,15 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
}
else if( internalModel )
{
T_field deviceField = spiceDeviceInfo.CreateField( &aSymbol, SIM_MODEL::DEVICE_TYPE_FIELD );
T_field deviceField = spiceDeviceInfo.CreateField( &aSymbol, SIM_DEVICE_TYPE_FIELD );
aSymbol.AddField( deviceField );
T_field typeField = spiceTypeInfo.CreateField( &aSymbol, SIM_MODEL::TYPE_FIELD );
T_field typeField = spiceTypeInfo.CreateField( &aSymbol, SIM_TYPE_FIELD );
aSymbol.AddField( typeField );
if( !spiceParamsInfo.IsEmpty() )
{
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_MODEL::PARAMS_FIELD );
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
aSymbol.AddField( paramsField );
}
@ -1732,10 +1732,10 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
spiceDeviceInfo.m_Text = SIM_MODEL::DeviceInfo( SIM_MODEL::DEVICE_T::SPICE ).fieldValue;
T_field deviceField = spiceDeviceInfo.CreateField( &aSymbol, SIM_MODEL::DEVICE_TYPE_FIELD );
T_field deviceField = spiceDeviceInfo.CreateField( &aSymbol, SIM_DEVICE_TYPE_FIELD );
aSymbol.AddField( deviceField );
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_MODEL::PARAMS_FIELD );
T_field paramsField = spiceParamsInfo.CreateField( &aSymbol, SIM_PARAMS_FIELD );
aSymbol.AddField( paramsField );
if( modelFromValueField )
@ -1756,7 +1756,7 @@ void SIM_MODEL::MigrateSimModel( T_symbol& aSymbol, const PROJECT* aProject )
if( !pinMapInfo.IsEmpty() )
{
T_field pinsField = pinMapInfo.CreateField( &aSymbol, SIM_MODEL::PINS_FIELD );
T_field pinsField = pinMapInfo.CreateField( &aSymbol, SIM_PINS_FIELD );
aSymbol.AddField( pinsField );
}
}

28
eeschema/sim/sim_model.h
View File

@ -45,6 +45,18 @@ class SIM_MODEL_SERIALIZER;
class PROJECT;
#define SIM_REFERENCE_FIELD wxT( "Reference" )
#define SIM_VALUE_FIELD wxT( "Value" )
#define SIM_DEVICE_TYPE_FIELD wxT( "Sim.Device" )
#define SIM_TYPE_FIELD wxT( "Sim.Type" )
#define SIM_PINS_FIELD wxT( "Sim.Pins" )
#define SIM_PARAMS_FIELD wxT( "Sim.Params" )
#define SIM_ENABLE_FIELD wxT( "Sim.Enable" )
#define SIM_LIBRARY_FIELD wxT( "Sim.Library" )
#define SIM_NAME_FIELD wxT( "Sim.Name" )
class SIM_MODEL
{
public:
@ -54,18 +66,6 @@ public:
struct PIN;
struct PARAM;
static constexpr auto REFERENCE_FIELD = "Reference";
static constexpr auto VALUE_FIELD = "Value";
static constexpr auto DEVICE_TYPE_FIELD = "Sim.Device";
static constexpr auto TYPE_FIELD = "Sim.Type";
static constexpr auto PINS_FIELD = "Sim.Pins";
static constexpr auto PARAMS_FIELD = "Sim.Params";
static constexpr auto ENABLE_FIELD = "Sim.Enable";
static constexpr auto LIBRARY_FIELD = "Sim.Library";
static constexpr auto NAME_FIELD = "Sim.Name";
// There's a trailing '_' because `DEVICE_TYPE` collides with something in Windows headers.
DEFINE_ENUM_CLASS_WITH_ITERATOR( DEVICE_T,
NONE,
@ -420,11 +420,11 @@ public:
bool aResolved, REPORTER* aReporter );
template <typename T>
static std::string GetFieldValue( const std::vector<T>* aFields, const std::string& aFieldName,
static std::string GetFieldValue( const std::vector<T>* aFields, const wxString& aFieldName,
bool aResolve = true );
template <typename T>
static void SetFieldValue( std::vector<T>& aFields, const std::string& aFieldName,
static void SetFieldValue( std::vector<T>& aFields, const wxString& aFieldName,
const std::string& aValue );
const SPICE_GENERATOR& SpiceGenerator() const { return *m_spiceGenerator; }

6
eeschema/sim/sim_model_serializer.cpp
View File

@ -175,7 +175,7 @@ void SIM_MODEL_SERIALIZER::ParseValue( const std::string& aValue )
{
try
{
tao::pegtl::string_input<> in( aValue, SIM_MODEL::VALUE_FIELD );
tao::pegtl::string_input<> in( aValue, "'Value' symbol field" );
auto root =
tao::pegtl::parse_tree::parse<SIM_MODEL_SERIALIZER_PARSER::fieldInferValueGrammar,
SIM_MODEL_SERIALIZER_PARSER::fieldInferValueSelector,
@ -206,7 +206,7 @@ void SIM_MODEL_SERIALIZER::ParseValue( const std::string& aValue )
bool SIM_MODEL_SERIALIZER::ParseParams( const std::string& aParams )
{
tao::pegtl::string_input<> in( aParams, SIM_MODEL::PARAMS_FIELD );
tao::pegtl::string_input<> in( aParams, "'Sim.Params' symbol field" );
std::unique_ptr<tao::pegtl::parse_tree::node> root;
try
@ -270,7 +270,7 @@ void SIM_MODEL_SERIALIZER::ParsePins( const std::string& aPins )
if( aPins == "" )
return;
tao::pegtl::string_input<> in( aPins, PINS_FIELD );
tao::pegtl::string_input<> in( aPins, "'Sim.Pins' symbol field" );
std::unique_ptr<tao::pegtl::parse_tree::node> root;
try