mirror of
https://gitlab.com/kicad/code/kicad.git
synced 2025-09-14 18:23:15 +02:00
0b2d4d4879
Recommendation is to avoid using the year nomenclature as this information is already encoded in the git repo. Avoids needing to repeatly update. Also updates AUTHORS.txt from current repo with contributor names
322 lines
8.7 KiB
C++
322 lines
8.7 KiB
C++
/**
|
|
* @file datafile_read_write.cpp
|
|
*/
|
|
|
|
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2016 Jean-Pierre Charras
|
|
* Copyright The KiCad Developers, see AUTHORS.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 3
|
|
* 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <wx/app.h>
|
|
#include <wx/msgdlg.h>
|
|
|
|
#include <build_version.h>
|
|
#include <calculator_panels/panel_regulator.h>
|
|
#include <class_regulator_data.h>
|
|
#include <datafile_read_write.h>
|
|
#include <string_utils.h>
|
|
#include <locale_io.h>
|
|
#include <macros.h>
|
|
#include <pcb_calculator_datafile_lexer.h>
|
|
#include <pcb_calculator_frame.h>
|
|
#include <pgm_base.h>
|
|
|
|
|
|
using namespace PCBCALC_DATA_T;
|
|
|
|
|
|
static const char* getTokenName( T aTok )
|
|
{
|
|
return PCB_CALCULATOR_DATAFILE_LEXER::TokenName( aTok );
|
|
}
|
|
|
|
|
|
bool PANEL_REGULATOR::ReadDataFile()
|
|
{
|
|
FILE* file = wxFopen( GetDataFilename(), wxT( "rt" ) );
|
|
|
|
if( file == nullptr )
|
|
return false;
|
|
|
|
// Switch the locale to standard C (needed to read/write floating point numbers)
|
|
LOCALE_IO toggle;
|
|
m_RegulatorList.Clear();
|
|
|
|
PCB_CALCULATOR_DATAFILE* datafile = new PCB_CALCULATOR_DATAFILE( &m_RegulatorList );
|
|
|
|
// dataReader dtor will close file
|
|
FILE_LINE_READER dataReader( file, GetDataFilename() );
|
|
PCB_CALCULATOR_DATAFILE_PARSER datafile_parser( &dataReader );
|
|
|
|
try
|
|
{
|
|
datafile_parser.Parse( datafile );
|
|
}
|
|
catch( const IO_ERROR& ioe )
|
|
{
|
|
delete datafile;
|
|
|
|
wxString msg = ioe.What();
|
|
|
|
msg += wxChar('\n');
|
|
msg += _("Data file error.");
|
|
|
|
wxMessageBox( msg );
|
|
return false;
|
|
}
|
|
|
|
m_choiceRegulatorSelector->Clear();
|
|
m_choiceRegulatorSelector->Append( m_RegulatorList.GetRegList() );
|
|
SelectLastSelectedRegulator();
|
|
|
|
delete datafile;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool PANEL_REGULATOR::WriteDataFile()
|
|
{
|
|
// Switch the locale to standard C (needed to read/write floating point numbers)
|
|
LOCALE_IO toggle;
|
|
|
|
auto datafile = std::make_unique<PCB_CALCULATOR_DATAFILE>( &m_RegulatorList );
|
|
|
|
try
|
|
{
|
|
FILE_OUTPUTFORMATTER formatter( GetDataFilename() );
|
|
|
|
int nestlevel = datafile->WriteHeader( &formatter );
|
|
|
|
datafile->Format( &formatter, nestlevel );
|
|
|
|
while( nestlevel-- )
|
|
formatter.Print( nestlevel, ")\n" );
|
|
}
|
|
catch( const IO_ERROR& )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_RegulatorListChanged = false;
|
|
return true;
|
|
}
|
|
|
|
|
|
PCB_CALCULATOR_DATAFILE::PCB_CALCULATOR_DATAFILE( REGULATOR_LIST * aList )
|
|
{
|
|
m_list = aList;
|
|
}
|
|
|
|
|
|
static const char* regtype_str[] =
|
|
{
|
|
"normal", "3terminal"
|
|
};
|
|
|
|
|
|
int PCB_CALCULATOR_DATAFILE::WriteHeader( OUTPUTFORMATTER* aFormatter ) const
|
|
{
|
|
int nestlevel = 0;
|
|
aFormatter->Print( nestlevel++, "(datafile\n");
|
|
aFormatter->Print( nestlevel++, "(version 2)\n" );
|
|
aFormatter->Print( nestlevel++, "(date %s)\n",
|
|
aFormatter->Quotew( GetISO8601CurrentDateTime() ).c_str() );
|
|
aFormatter->Print( nestlevel++, "(tool %s)\n",
|
|
aFormatter->Quotew( Pgm().App().GetAppName() +
|
|
wxChar(' ') + GetBuildVersion() ).c_str() );
|
|
|
|
return nestlevel;
|
|
}
|
|
|
|
void PCB_CALCULATOR_DATAFILE::Format( OUTPUTFORMATTER* aFormatter,
|
|
int aNestLevel ) const
|
|
{
|
|
// Write regulators list:
|
|
aFormatter->Print( aNestLevel++, "(%s\n", getTokenName( T_regulators ) );
|
|
|
|
for( REGULATOR_DATA* item : m_list->m_List )
|
|
{
|
|
aFormatter->Print( aNestLevel, "(%s %s\n", getTokenName( T_regulator ),
|
|
aFormatter->Quotew( item->m_Name ).c_str() );
|
|
|
|
aFormatter->Print( aNestLevel + 1, "(%s %g)\n", getTokenName( T_reg_vref_min ),
|
|
item->m_VrefMin );
|
|
aFormatter->Print( aNestLevel + 1, "(%s %g)\n", getTokenName( T_reg_vref_typ ),
|
|
item->m_VrefTyp );
|
|
aFormatter->Print( aNestLevel + 1, "(%s %g)\n", getTokenName( T_reg_vref_max ),
|
|
item->m_VrefMax );
|
|
|
|
if( item->m_Type == 1 )
|
|
{
|
|
aFormatter->Print( aNestLevel + 1, "(%s %g)\n", getTokenName( T_reg_iadj_typ ),
|
|
item->m_IadjTyp );
|
|
aFormatter->Print( aNestLevel + 1, "(%s %g)\n", getTokenName( T_reg_iadj_max ),
|
|
item->m_IadjMax );
|
|
}
|
|
|
|
aFormatter->Print( aNestLevel+1, "(%s %s)\n", getTokenName( T_reg_type ),
|
|
regtype_str[item->m_Type] );
|
|
aFormatter->Print( aNestLevel, ")\n" );
|
|
}
|
|
|
|
aFormatter->Print( --aNestLevel, ")\n" );
|
|
}
|
|
|
|
|
|
void PCB_CALCULATOR_DATAFILE::Parse( PCB_CALCULATOR_DATAFILE_PARSER* aParser )
|
|
{
|
|
aParser->Parse( this );
|
|
}
|
|
|
|
|
|
PCB_CALCULATOR_DATAFILE_PARSER::PCB_CALCULATOR_DATAFILE_PARSER( LINE_READER* aReader ) :
|
|
PCB_CALCULATOR_DATAFILE_LEXER( aReader )
|
|
{
|
|
}
|
|
|
|
|
|
PCB_CALCULATOR_DATAFILE_PARSER::PCB_CALCULATOR_DATAFILE_PARSER( char* aLine,
|
|
const wxString& aSource ) :
|
|
PCB_CALCULATOR_DATAFILE_LEXER( aLine, aSource )
|
|
{
|
|
}
|
|
|
|
|
|
void PCB_CALCULATOR_DATAFILE_PARSER::Parse( PCB_CALCULATOR_DATAFILE* aDataList )
|
|
{
|
|
T token;
|
|
|
|
while( ( token = NextTok() ) != T_EOF)
|
|
{
|
|
if( token == T_LEFT )
|
|
{
|
|
token = NextTok();
|
|
|
|
if( token == T_regulators )
|
|
{
|
|
ParseRegulatorDescr( aDataList );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void PCB_CALCULATOR_DATAFILE_PARSER::ParseRegulatorDescr( PCB_CALCULATOR_DATAFILE* aDataList )
|
|
{
|
|
T token;
|
|
wxString name;
|
|
double vrefmin, vreftyp, vrefmax = 0.0;
|
|
double iadjtyp, iadjmax = 0.0;
|
|
|
|
auto parseToken = [&]()
|
|
{
|
|
double val;
|
|
token = NextTok();
|
|
|
|
if( token != T_NUMBER )
|
|
Expecting( T_NUMBER );
|
|
|
|
sscanf( CurText(), "%lf", &val );
|
|
NeedRIGHT();
|
|
return val;
|
|
};
|
|
|
|
int type;
|
|
|
|
while( ( token = NextTok() ) != T_RIGHT )
|
|
{
|
|
if( token == T_EOF)
|
|
Unexpected( T_EOF );
|
|
|
|
if( token == T_LEFT )
|
|
token = NextTok();
|
|
|
|
if( token == T_regulator )
|
|
{
|
|
type = 0;
|
|
vrefmin = 0.0;
|
|
vreftyp = 0.0;
|
|
vrefmax = 0.0;
|
|
iadjtyp = 0.0;
|
|
iadjmax = 0.0;
|
|
|
|
// Read name
|
|
token = NextTok();
|
|
name = From_UTF8( CurText() );
|
|
|
|
while( ( token = NextTok() ) != T_RIGHT )
|
|
{
|
|
if( token == T_EOF)
|
|
Unexpected( T_EOF );
|
|
|
|
if( token == T_LEFT )
|
|
token = NextTok();
|
|
|
|
switch( token )
|
|
{
|
|
// Parse legacy entry
|
|
case T_reg_vref:
|
|
vreftyp = parseToken();
|
|
vrefmin = vreftyp;
|
|
vrefmax = vreftyp;
|
|
break;
|
|
|
|
case T_reg_vref_min: vrefmin = parseToken(); break;
|
|
case T_reg_vref_typ: vreftyp = parseToken(); break;
|
|
case T_reg_vref_max: vrefmax = parseToken(); break;
|
|
|
|
// Parse legacy entry
|
|
case T_reg_iadj:
|
|
iadjtyp = parseToken();
|
|
iadjmax = iadjtyp;
|
|
break;
|
|
|
|
case T_reg_iadj_typ: iadjtyp = parseToken(); break;
|
|
case T_reg_iadj_max: iadjmax = parseToken(); break;
|
|
|
|
case T_reg_type: // type: normal or 3 terminal reg
|
|
token = NextTok();
|
|
|
|
if( strcasecmp( CurText(), regtype_str[0] ) == 0 )
|
|
type = 0;
|
|
else if( strcasecmp( CurText(), regtype_str[1] ) == 0 )
|
|
type = 1;
|
|
else
|
|
Unexpected( CurText() );
|
|
|
|
NeedRIGHT();
|
|
break;
|
|
|
|
default:
|
|
Unexpected( CurText() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( ! name.IsEmpty() )
|
|
{
|
|
REGULATOR_DATA* new_item = new REGULATOR_DATA( name, vrefmin, vreftyp, vrefmax,
|
|
type, iadjtyp, iadjmax );
|
|
aDataList->m_list->Add( new_item );
|
|
}
|
|
}
|
|
}
|
|
}
|