ibis_parser.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2022 Fabien Corona f.corona<at>laposte.net
 * Copyright (C) 2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
 * to endorse or promote products derived from this software without specific
 * prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
 
#include "ibis_parser.h"
 
#include <sstream>
#include <cstring> //for memcmp
#include <iterator>
#include <locale_io.h> // KiCad header
 
// _() is used here to mark translatable strings in IBIS_REPORTER::Report()
// However, currently non ASCII7 chars are nor correctly handled when printing messages
// So we disable translations
#if 0
#include <wx/intl.h> // for _() macro and wxGetTranslation()
#else
#undef _
#define _( x ) x
#endif
 
 
bool IbisParser::compareIbisWord( const std::string& stra, const std::string& strb )
{
 return std::equal( stra.begin(), stra.end(),
 strb.begin(), strb.end(),
 [](char a, char b)
 {
 return std::tolower(a) == std::tolower(b);
 });
}
 
bool IBIS_MATRIX_BANDED::Check()
{
 bool status = true;
 
 if( m_dim < 1 )
 {
 Report( _( "Dimension of matrices should be >= 1." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_bandwidth < 1 )
 {
 Report( _( "Bandwidth of banded matrices should be >= 1." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 for( int i = 0; i < m_bandwidth * m_dim; i++ )
 {
 if( std::isnan( m_data[i] ) )
 {
 Report( _( "There are NaN elements in a matrix." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 
 
 return status;
}
 
bool IBIS_MATRIX_FULL::Check()
{
 bool status = true;
 
 if( m_dim < 1 )
 {
 Report( _( "Dimension of matrices should be >= 1." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 for( int i = 0; i < m_dim * m_dim; i++ )
 {
 if( std::isnan( m_data[i] ) )
 {
 Report( _( "There are NaN elements in a matrix." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 
 
 return status;
}
 
bool IBIS_MATRIX_SPARSE::Check()
{
 bool status = true;
 
 if( m_dim < 1 )
 {
 Report( _( "Dimension of matrices should be >= 1." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 for( int i = 0; i < m_dim * m_dim; i++ )
 {
 if( std::isnan( m_data[i] ) )
 {
 Report( _( "There are NaN elements in a matrix." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 
 
 return status;
}
 
bool isNumberNA( double aNumber )
{
 double NA = nan( NAN_NA );
 return std::memcmp( &aNumber, &NA, sizeof NA ) == 0;
}
 
bool TypMinMaxValue::Check()
{
 bool status = true;
 
 if( std::isnan( value[IBIS_CORNER::TYP] ) )
 status = false;
 if( std::isnan( value[IBIS_CORNER::MIN] ) && !isNumberNA( value[IBIS_CORNER::MIN] ) )
 status = false;
 if( std::isnan( value[IBIS_CORNER::MAX] ) && !isNumberNA( value[IBIS_CORNER::MAX] ) )
 status = false;
 
 return status;
}
 
bool IbisComponentPackage::Check()
{
 bool status = true;
 
 if( !m_Rpkg.Check() )
 {
 Report( _( "Invalid R_pkg value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_Lpkg.Check() )
 {
 Report( _( "Invalid L_pkg value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_Cpkg.Check() )
 {
 Report( _( "Invalid C_pkg value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 return status;
}
 
bool IbisComponentPin::Check()
{
 bool status = true;
 
 if( !m_dummy )
 {
 std::stringstream message;
 message << _( "Checking pin " ) << m_pinName;
 
 if( m_pinName.empty() )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Pin name cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( m_signalName.empty() )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Signal name cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( m_modelName.empty() )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Model name cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_Rpin ) && !isNumberNA( m_Rpin ) )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Rpin is not valid." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_Lpin )&& !isNumberNA( m_Lpin ) )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Lpin is not valid." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_Cpin )&& !isNumberNA( m_Cpin ) )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Cpin is not valid." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 
 return status;
}
 
 
bool IbisComponent::Check()
{
 bool status = true;
 
 std::stringstream message;
 message << _( "Checking component " ) << m_name;
 
 if( m_name.empty() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Component: name cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_manufacturer.empty() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Component: manufacturer cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( !m_package.Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Component: invalid package." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_pins.size() < 1 )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Component: no pin" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 for( IbisComponentPin& pin : m_pins )
 {
 status &= pin.Check();
 }
 
 return status;
}
 
 
bool IbisModelSelector::Check()
{
 return true;
}
 
 
std::string IBIS_ANY::doubleToString( double aNumber )
{
 std::ostringstream ss;
 ss.setf( std::ios_base::scientific, std::ios_base::floatfield );
 ss << aNumber;
 return ss.str();
}
 
 
std::string IVtable::Spice( int aN, std::string aPort1, std::string aPort2, std::string aModelName,
 IBIS_CORNER aCorner )
{
 std::string result = "";
 
 if( m_entries.size() > 0 )
 {
 result += "a";
 result += std::to_string( aN );
 result += " %vd(";
 result += aPort1;
 result += " ";
 result += aPort2;
 result += ") %id(";
 result += aPort1;
 result += " ";
 result += aPort2;
 result += ") ";
 result += aModelName;
 result += "\n";
 result += "\n";
 result += ".model ";
 result += aModelName;
 result += " pwl(\n+ x_array=[";
 
 for( IVtableEntry& entry : m_entries )
 {
 result += doubleToString( entry.V );
 result += "\n+";
 }
 result += "]\n+ y_array=[";
 
 for( IVtableEntry& entry : m_entries )
 {
 result += doubleToString( entry.I.value[aCorner] );
 result += "\n+";
 }
 result += "]\n+ input_domain=0.05 fraction=TRUE)\n\n";
 }
 return result;
}
 
double IVtable::InterpolatedI( double aV, IBIS_CORNER aCorner )
{
 // @TODO change this algorithm
 
 if( m_entries.back().V > m_entries.at( 0 ).V )
 {
 if( aV >= m_entries.back().V )
 {
 return m_entries.back().I.value[aCorner];
 }
 
 if( aV <= m_entries.at( 0 ).V )
 {
 return m_entries.at( 0 ).I.value[aCorner];
 }
 
 for( size_t i = 1; i < m_entries.size(); i++ )
 {
 if( m_entries.at( i ).V > aV )
 {
 return m_entries.at( i - 1 ).I.value[aCorner]
 + ( m_entries.at( i ).I.value[aCorner]
 - m_entries.at( i - 1 ).I.value[aCorner] )
 / ( m_entries.at( i ).V - m_entries.at( i - 1 ).V )
 * ( aV - m_entries.at( i - 1 ).V );
 }
 }
 Report( _( "Cannot interpolate the current based on this IV table." ), RPT_SEVERITY_ERROR );
 return nan( "" );
 }
 else
 {
 // exiting the function here would mean the IV table is reversed.
 return nan( "" );
 }
 // @TODO prefer another method such as a dichotomy
}
 
bool IVtable::Check()
{
 bool status = true;
 for( IVtableEntry& entry : m_entries )
 {
 if( std::isnan( entry.V ) )
 {
 Report( _( "There is an invalid voltage in an IV table" ), RPT_SEVERITY_ERROR );
 status = false;
 break;
 }
 
 if( !entry.I.Check() )
 {
 Report( _( "There is an invalid current in an IV table" ), RPT_SEVERITY_ERROR );
 status = false;
 break;
 }
 }
 // TODO: Check if the IV table is monotonic :
 // IBIS standard defines 8 criteria for an IV table to be monotonic
 // Issue a warning, not an error
 
 return status;
}
 
 
bool dvdtTypMinMax::Check()
{
 bool status = true;
 
 if( std::isnan( value[IBIS_CORNER::TYP].m_dv ) )
 status = false;
 if( std::isnan( value[IBIS_CORNER::TYP].m_dt ) )
 status = false;
 
 
 if( std::isnan( value[IBIS_CORNER::MIN].m_dv ) && !isNumberNA( value[IBIS_CORNER::MIN].m_dv ) )
 status = false;
 if( std::isnan( value[IBIS_CORNER::MIN].m_dt ) && !isNumberNA( value[IBIS_CORNER::MIN].m_dt ) )
 status = false;
 
 if( std::isnan( value[IBIS_CORNER::MIN].m_dv ) && !isNumberNA( value[IBIS_CORNER::MIN].m_dv ) )
 status = false;
 if( std::isnan( value[IBIS_CORNER::MIN].m_dt ) && !isNumberNA( value[IBIS_CORNER::MIN].m_dt ) )
 status = false;
 
 return status;
}
 
bool IbisRamp::Check()
{
 bool status = true;
 
 if( std::isnan( m_Rload ) )
 {
 status = false;
 Report( _( "Invalid R_load." ), RPT_SEVERITY_ERROR );
 }
 if( !m_falling.Check() )
 {
 Report( _( "Invalid falling dV/dt." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_rising.Check() )
 {
 Report( _( "Invalid rising dV/dt." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 return status;
}
 
 
 
bool IbisModel::Check()
{
 bool status = true;
 
 if( m_name.empty() )
 {
 Report( _( "Model name cannot be empty" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 std::stringstream message;
 message << _( "Checking model " ) << m_name;
 
 if(m_type == IBIS_MODEL_TYPE::UNDEFINED)
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Undefined model type." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( std::isnan( m_vinh ) && !isNumberNA( m_vinh ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid Vinh value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_vinl ) && !isNumberNA( m_vinl ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid Vinl value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_rref ) && !isNumberNA( m_rref ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid R_ref value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_cref ) && !isNumberNA( m_cref ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid C_ref value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_vref ) && !isNumberNA( m_vref ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid V_ref value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( std::isnan( m_vmeas ) && !isNumberNA( m_vmeas ) )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Invalid V_meas value." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_C_comp.Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "C_comp is invalid." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_temperatureRange.Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Temperature Range is invalid." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( !m_voltageRange.Check() )
 {
 // If the voltage range is not valid, it's ok, only if we have pulls and clamps
 if( !m_pulldownReference.Check() )
 {
 status = false;
 }
 if( !m_pullupReference.Check() )
 {
 status = false;
 }
 if( !m_GNDClampReference.Check() )
 {
 status = false;
 }
 if( !m_POWERClampReference.Check() )
 {
 status = false;
 }
 if( !status )
 {
 Report( _( "Voltage Range is invalid." ), RPT_SEVERITY_ERROR );
 }
 status = false;
 }
 if( !m_pulldown.Check() )
 {
 Report( _( "Invalid pulldown." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_pullup.Check() )
 {
 Report( _( "Invalid pullup." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_POWERClamp.Check() )
 {
 Report( _( "Invalid POWER clamp." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !m_GNDClamp.Check() )
 {
 Report( _( "Invalid GND clamp." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( m_type != IBIS_MODEL_TYPE::INPUT_ECL && m_type != IBIS_MODEL_TYPE::INPUT_STD
 && m_type != IBIS_MODEL_TYPE::TERMINATOR && m_type != IBIS_MODEL_TYPE::SERIES
 && m_type != IBIS_MODEL_TYPE::SERIES_SWITCH )
 {
 if( !m_ramp.Check() )
 {
 Report( _( "Invalid Ramp" ), RPT_SEVERITY_ERROR );
 }
 }
 return status;
}
 
bool IbisHeader::Check()
{
 bool status = true;
 
 std::stringstream message;
 message << _( "Checking Header..." );
 
 if( m_ibisVersion == -1 )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Missing [IBIS Ver]" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_ibisVersion > IBIS_MAX_VERSION )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "The parser does not handle this IBIS version" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_fileRevision == -1 )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Missing [File Rev]" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_fileName.empty() )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Missing [File Name]" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 std::string ext = m_fileName.substr( m_fileName.length() - 4 );
 
 if( !( !strcmp( ext.c_str(), ".ibs" ) || !strcmp( ext.c_str(), ".pkg" )
 || !strcmp( ext.c_str(), ".ebd" ) || !strcmp( ext.c_str(), ".ims" ) ) )
 {
 if(status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( "Invalid file extension in [File Name]", RPT_SEVERITY_ERROR );
 status = false;
 }
 
 
 return status;
}
 
bool IbisPackageModel::Check()
{
 bool status = true;
 
 if( m_name.empty() )
 {
 Report( _( "Package model name cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 std::stringstream message;
 message << _( "Checking package model " ) << m_name;
 
 if( m_manufacturer.empty() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Manufacturer cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_OEM.empty() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "OEM cannot be empty." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_numberOfPins < 0 )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Negative number of pins." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( (int)m_pins.size() != m_numberOfPins )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( "Number of pins does not match [Pin Numbers] size.", RPT_SEVERITY_ERROR );
 status = false;
 }
 
 for( size_t i = 0; i < m_pins.size(); i++ )
 {
 if( m_pins.at( i ).empty() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Empty pin number." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 // resistance matrix is not required
 
 if( !( m_resistanceMatrix )->Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Resistance matrix is incorrect." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_capacitanceMatrix != nullptr )
 {
 if( m_capacitanceMatrix->m_type == IBIS_MATRIX_TYPE::UNDEFINED )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Capacitance matrix is undefined." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( !m_capacitanceMatrix->Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Capacitance matrix is incorrect." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Capacitance matrix is nullptr." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( m_inductanceMatrix != nullptr )
 {
 if( m_inductanceMatrix->m_type == IBIS_MATRIX_TYPE::UNDEFINED )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Inductance matrix is undefined." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( !m_inductanceMatrix->Check() )
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Inductance matrix is incorrect." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else
 {
 if( status )
 Report( message.str(), RPT_SEVERITY_ACTION );
 
 Report( _( "Inductance matrix is nullptr." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 return status;
}
 
 
bool IbisParser::ParseFile( std::string& aFileName )
{
 std::stringstream err_msg;
 
 std::ifstream ibisFile;
 ibisFile.open( aFileName );
 
 if( !ibisFile.is_open() )
 {
 err_msg << _( "Cannot open file " ) << aFileName;
 Report( err_msg.str(), RPT_SEVERITY_ERROR );
 return false;
 }
 
 std::ostringstream ss;
 ss << ibisFile.rdbuf();
 const std::string& s = ss.str();
 m_buffer = std::vector<char>( s.begin(), s.end() );
 m_buffer.push_back( 0 );
 
 long size = m_buffer.size();
 
 m_lineCounter = 0;
 m_bufferIndex = 0;
 
 bool status = true;
 
 LOCALE_IO toggle; // Temporary switch the locale to standard C to r/w floats
 
 while( ( m_bufferIndex < size ) && status )
 {
 if( !getNextLine() )
 {
 Report( _( "Unexpected end of file. Missing [END] ?" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 
 if( status && m_parrot )
 {
 printLine();
 }
 
 if( status && !onNewLine() )
 {
 err_msg.clear();
 err_msg << _( "Error on line " ) << std::to_string( m_lineCounter );
 Report( err_msg.str(), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( m_context == IBIS_PARSER_CONTEXT::END )
 {
 break;
 }
 }
 
 m_buffer.clear();
 return status;
}
 
void IbisParser::skipWhitespaces()
{
 while( ( isspace( m_buffer[m_lineOffset + m_lineIndex] ) ) && ( m_lineIndex < m_lineLength ) )
 {
 m_lineIndex++;
 }
}
 
bool IbisParser::checkEndofLine()
{
 skipWhitespaces();
 
 if( m_lineIndex < m_lineLength )
 {
 Report( _( "A line did not end properly." ), RPT_SEVERITY_ERROR );
 return false;
 }
 return true;
}
 
 
bool IbisParser::isLineEmptyFromCursor()
{
 int cursor = m_lineIndex;
 
 while( ( isspace( m_buffer[m_lineOffset + cursor] ) ) && ( cursor < m_lineLength ) )
 {
 cursor++;
 }
 
 return ( cursor >= m_lineLength );
}
 
bool IbisParser::readDvdt( std::string& aString, dvdt& aDest )
{
 bool status = true;
 
 if( aString == "NA" )
 {
 aDest.m_dv = nan( NAN_NA );
 aDest.m_dt = nan( NAN_NA );
 
 return status;
 }
 
 int i = 0;
 
 for( i = 1; i < (int)aString.length(); i++ )
 {
 if( aString.at( i ) == '/' )
 {
 break;
 }
 }
 
 if( aString.at( i ) == '/' )
 {
 std::string str1 = aString.substr( 0, i );
 std::string str2 = aString.substr( i + 1, aString.size() - i - 1 );
 
 if( !parseDouble( aDest.m_dv, str1, true ) || !parseDouble( aDest.m_dt, str2, true ) )
 {
 status = false;
 }
 }
 
 return status;
}
 
 
bool IbisParser::parseDouble( double& aDest, std::string& aStr, bool aAllowModifiers )
{
 // " an entry of the C matrix could be given as 1.23e-12 or as 1.23p or 1.23pF."
 // Kibis: This implementation will also allow 1.23e-3n
 
 skipWhitespaces();
 bool status = true;
 bool converted = false;
 
 std::string str = aStr;
 
 double result;
 size_t size = 0;
 
 
 if( str == "NA" )
 {
 result = nan( NAN_NA );
 }
 else
 {
 try
 {
 result = std::stod( str, &size );
 converted = true;
 }
 catch( ... )
 {
 result = nan( NAN_INVALID );
 status = false;
 }
 }
 
 if( converted && ( size < str.length() ) )
 {
 switch( static_cast<char>( str.at( size ) ) )
 {
 case 'T': result *= 1e12; break;
 case 'G': result *= 1e9; break;
 case 'M': result *= 1e6; break;
 case 'k': result *= 1e3; break;
 case 'm': result *= 1e-3; break;
 case 'u': result *= 1e-6; break;
 case 'n': result *= 1e-9; break;
 case 'p': result *= 1e-12; break;
 case 'f': result *= 1e-15; break;
 default:
 break;
 // In some files, "vinh = 3.0V", therefore we can't return false in the default case
 }
 }
 
 aDest = result;
 
 return status;
}
 
 
bool IbisParser::getNextLine()
{
 m_lineCounter++;
 
 long tmpIndex = m_bufferIndex;
 
 m_lineOffset = m_bufferIndex;
 
 if( m_bufferIndex >= (int)m_buffer.size() )
 return false;
 
 char c = m_buffer[m_bufferIndex++];
 
 int i = 1;
 while( c != m_commentChar && c != 0 && c != '\n' && i < IBIS_MAX_LINE_LENGTH )
 {
 c = m_buffer[m_bufferIndex++];
 i++;
 }
 
 if( i == IBIS_MAX_LINE_LENGTH )
 {
 Report( _( "Line exceeds maximum length." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 m_lineLength = m_bufferIndex - tmpIndex - 1; // Don't add the end of line condition
 m_lineIndex = 0;
 
 if( c == m_commentChar )
 {
 while( c != 0 && c != '\n' )
 {
 c = m_buffer[m_bufferIndex++];
 }
 }
 
 if( i == IBIS_MAX_LINE_LENGTH )
 {
 Report( _( "Line exceeds maximum length." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 return true;
}
 
 
void IbisParser::printLine()
{
 for( int i = 0; i < m_lineLength; i++ )
 {
 std::cout << m_buffer[m_lineOffset + i];
 }
 std::cout << std::endl;
}
 
bool IbisParser::readDouble( double& aDest )
{
 bool status = true;
 std::string str;
 
 if( readWord( str ) )
 {
 if( !parseDouble( aDest, str, true ) )
 {
 Report( _( "Failed to read a double." ), RPT_SEVERITY_WARNING );
 status = false;
 }
 }
 else
 {
 Report( _( "Failed to read a word." ), RPT_SEVERITY_WARNING );
 status = false;
 }
 
 return status;
}
 
bool IbisParser::readInt( int& aDest )
{
 bool status = true;
 std::string str;
 
 if( readWord( str ) )
 {
 double result;
 size_t size = 0;
 
 try
 {
 result = std::stoi( str, &size );
 }
 catch( ... )
 {
 if( str == "NA" )
 {
 result = nan( NAN_NA );
 }
 else
 {
 result = nan( NAN_INVALID );
 status = false;
 }
 }
 
 if( size != str.size() )
 {
 status = false;
 Report( _( "Number is not an integer" ), RPT_SEVERITY_WARNING );
 }
 
 aDest = result;
 }
 else
 {
 Report( _( "Failed to read a word." ), RPT_SEVERITY_WARNING );
 status = false;
 }
 
 return status;
}
 
bool IbisParser::readWord( std::string& aDest )
{
 skipWhitespaces();
 
 int startIndex = m_lineIndex;
 
 while( ( !isspace( m_buffer[m_lineOffset + m_lineIndex] ) ) && ( m_lineIndex < m_lineLength ) )
 {
 m_lineIndex++;
 }
 
 std::vector<char>::iterator start = std::next( m_buffer.begin(), m_lineOffset + startIndex );
 std::vector<char>::iterator end = std::next( m_buffer.begin(), m_lineOffset + m_lineIndex );
 aDest = std::string( start, end );
 
 return ( aDest.size() > 0 );
}
 
bool IbisParser::readString( std::string& aDest )
{
 while( m_lineIndex < m_lineLength )
 {
 aDest += m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 // Remove extra whitespace characters
 int len = aDest.length();
 
 if( len < 1 )
 {
 // The data is likely on the next line. Skip.
 return true;
 }
 
 char c = aDest[len - 1];
 int i = 0;
 
 while( isspace( c ) && ( i < len ) )
 {
 c = aDest[len - 1 - i];
 i++;
 }
 aDest = aDest.substr( 0, len - i + 1 );
 
 return true;
}
 
bool IbisParser::storeString( std::string& aDest, bool aMultiline )
{
 bool status = true;
 
 skipWhitespaces();
 
 status &= readString( aDest );
 
 m_continue = aMultiline ? IBIS_PARSER_CONTINUE::STRING : IBIS_PARSER_CONTINUE::NONE;
 m_continuingString = &aDest;
 
 status &= checkEndofLine();
 return status;
}
 
 
bool IbisParser::changeCommentChar()
{
 skipWhitespaces();
 
 std::string strChar = "";
 
 // We cannot stop at m_lineLength here, because lineLength could stop before |_char
 // if the char remains the same
 
 char c = m_buffer[m_lineOffset + m_lineIndex++];
 char d = c;
 
 if( !( c == '!' || c == '"' || c == '#' || c == '$' || c == '%' || c == '&' || c == '\''
 || c == '(' || c == ')' || c == '*' || c == ',' || c == ':' || c == ';' || c == '<'
 || c == '>' || c == '?' || c == '@' || c == '\\' || c == '^' || c == '`' || c == '{'
 || c == '|' || c == '}' || c == '~' || c == ')' ) )
 {
 Report( _( "New comment character is invalid." ), RPT_SEVERITY_ERROR );
 }
 
 c = m_buffer[m_lineOffset + m_lineIndex++];
 
 while( ( !isspace( c ) ) && c != 0 && c != '\n' )
 {
 strChar += c;
 c = m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 if( strChar != "_char" )
 {
 Report( _( "Invalid syntax. Should be |_char or &_char, etc..." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 while( isspace( c ) && c != 0 && c != '\n' && c != d )
 {
 c = m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 if( ( !isspace( c ) ) && c != d )
 {
 Report( _( "No extra argument was expected" ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 m_commentChar = d;
 
 
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 
 return true;
}
 
std::string IbisParser::getKeyword()
{
 std::string keyword = "";
 //"Keywords must be enclosed in square brackets, “[]”, and must start in column 1 of the line."
 //"No space or tab is allowed immediately after the opening bracket “[” or immediately"
 // "before the closing bracket “]"
 
 if( m_buffer[m_lineOffset + m_lineIndex] != '[' )
 {
 // We return an empty keyword, this should stop the parser.
 return "";
 }
 
 m_lineIndex++;
 
 char c;
 c = m_buffer[m_lineOffset + m_lineIndex++];
 
 while( ( c != ']' )
 && ( m_lineIndex
 < m_lineLength ) ) // We know the maximum keyword length, we could add a condition.
 {
 // "Underscores and spaces are equivalent in keywords"
 if( c == ' ' )
 {
 c = '_';
 }
 keyword += c;
 c = m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 return keyword;
}
 
bool IbisParser::changeContext( std::string& aKeyword )
{
 bool status = true;
 
 if( status )
 {
 switch( m_context )
 {
 case IBIS_PARSER_CONTEXT::HEADER: status &= m_ibisFile.m_header.Check(); break;
 case IBIS_PARSER_CONTEXT::COMPONENT: status &= m_currentComponent->Check(); break;
 case IBIS_PARSER_CONTEXT::MODEL: status &= m_currentModel->Check(); break;
 case IBIS_PARSER_CONTEXT::MODELSELECTOR: status &= m_currentModelSelector->Check(); break;
 case IBIS_PARSER_CONTEXT::PACKAGEMODEL: status &= m_currentPackageModel->Check(); break;
 case IBIS_PARSER_CONTEXT::END:
 Report( "Cannot change context after [END]" );
 status = false;
 break;
 
 default: Report( "Changing context from an undefined context" );
 }
 }
 
 if( !compareIbisWord( aKeyword.c_str(), "End" ) && status )
 {
 //New context
 if( compareIbisWord( aKeyword.c_str(), "Component" ) )
 {
 m_ibisFile.m_components.push_back( IbisComponent( m_reporter ) );
 m_currentComponent = &( m_ibisFile.m_components.back() );
 status &= storeString( m_currentComponent->m_name, false );
 m_context = IBIS_PARSER_CONTEXT::COMPONENT;
 }
 else if( compareIbisWord( aKeyword.c_str(), "Model_Selector" ) )
 {
 IbisModelSelector MS( m_reporter );
 status &= storeString( MS.m_name, false );
 m_ibisFile.m_modelSelectors.push_back( MS );
 m_currentModelSelector = &( m_ibisFile.m_modelSelectors.back() );
 m_context = IBIS_PARSER_CONTEXT::MODELSELECTOR;
 m_continue = IBIS_PARSER_CONTINUE::MODELSELECTOR;
 }
 else if( compareIbisWord( aKeyword.c_str(), "Model" ) )
 {
 IbisModel model( m_reporter );
 model.m_temperatureRange.value[IBIS_CORNER::MIN] = 0;
 model.m_temperatureRange.value[IBIS_CORNER::TYP] = 50;
 model.m_temperatureRange.value[IBIS_CORNER::MAX] = 100;
 status &= storeString( model.m_name, false );
 m_ibisFile.m_models.push_back( model );
 m_currentModel = &( m_ibisFile.m_models.back() );
 m_context = IBIS_PARSER_CONTEXT::MODEL;
 m_continue = IBIS_PARSER_CONTINUE::MODEL;
 }
 else if( compareIbisWord( aKeyword.c_str(), "Define_Package_Model" ) )
 {
 IbisPackageModel PM( m_reporter );
 PM.m_resistanceMatrix = std::unique_ptr<IBIS_MATRIX>( new IBIS_MATRIX( m_reporter ) );
 PM.m_capacitanceMatrix = std::unique_ptr<IBIS_MATRIX>( new IBIS_MATRIX( m_reporter ) );
 PM.m_inductanceMatrix = std::unique_ptr<IBIS_MATRIX>( new IBIS_MATRIX( m_reporter ) );
 
 PM.m_resistanceMatrix->m_type = IBIS_MATRIX_TYPE::UNDEFINED;
 PM.m_capacitanceMatrix->m_type = IBIS_MATRIX_TYPE::UNDEFINED;
 PM.m_inductanceMatrix->m_type = IBIS_MATRIX_TYPE::UNDEFINED;
 
 PM.m_resistanceMatrix->m_dim = -1;
 PM.m_capacitanceMatrix->m_dim = -1;
 PM.m_inductanceMatrix->m_dim = -1;
 
 status &= storeString( PM.m_name, false );
 
 m_ibisFile.m_packageModels.push_back( PM );
 m_currentPackageModel = &( m_ibisFile.m_packageModels.back() );
 m_context = IBIS_PARSER_CONTEXT::PACKAGEMODEL;
 }
 else if( compareIbisWord( aKeyword.c_str(), "End_Package_Model" ) )
 {
 if( m_currentComponent != nullptr )
 {
 m_context = IBIS_PARSER_CONTEXT::COMPONENT;
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 }
 else // .pkg file, we just go back to header, to get the [END] keyword
 { // This will cause the header to be checked twice.
 m_context = IBIS_PARSER_CONTEXT::HEADER;
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 }
 }
 else
 {
 status = false;
 std::string context_string;
 
 switch( m_context )
 {
 case IBIS_PARSER_CONTEXT::HEADER: context_string += "HEADER"; break;
 case IBIS_PARSER_CONTEXT::COMPONENT: context_string += "COMPONENT"; break;
 case IBIS_PARSER_CONTEXT::MODELSELECTOR: context_string += "MODEL_SELECTOR"; break;
 case IBIS_PARSER_CONTEXT::MODEL: context_string += "MODEL"; break;
 case IBIS_PARSER_CONTEXT::PACKAGEMODEL: context_string += "PACKAGE_MODEL"; break;
 case IBIS_PARSER_CONTEXT::PACKAGEMODEL_MODELDATA:
 context_string += "PACKAGE_MODEL_MODEL_DATA";
 break;
 default: context_string += "???"; break;
 }
 
 std::stringstream message;
 message << _( "Unknown keyword in " ) << context_string << _( " context: " ) << aKeyword;
 Report( message.str(), RPT_SEVERITY_ERROR );
 }
 }
 else
 {
 m_context = IBIS_PARSER_CONTEXT::END;
 }
 
 return status;
}
 
 
bool IbisParser::parseModelSelector( std::string& aKeyword )
{
 bool status = true;
 
 if( !changeContext( aKeyword ) )
 {
 status = false;
 }
 return status;
}
 
 
bool IbisParser::readRampdvdt( dvdtTypMinMax& aDest )
{
 bool status = true;
 std::string str;
 
 if( readWord( str ) )
 {
 status &= readDvdt( str, aDest.value[IBIS_CORNER::TYP] )
 && readDvdt( str, aDest.value[IBIS_CORNER::MIN] )
 && readDvdt( str, aDest.value[IBIS_CORNER::MAX] );
 }
 else
 {
 status = false;
 }
 
 return status;
}
 
bool IbisParser::readRamp()
{
 bool status = true;
 
 m_continue = IBIS_PARSER_CONTINUE::RAMP;
 
 if( !readNumericSubparam( std::string( "R_load" ), m_currentModel->m_ramp.m_Rload ) )
 {
 std::string str;
 
 if( readWord( str ) )
 {
 if( !strcmp( str.c_str(), "dV/dt_r" ) )
 {
 status &= readRampdvdt( m_currentModel->m_ramp.m_rising );
 }
 else if( !strcmp( str.c_str(), "dV/dt_f" ) )
 {
 status &= readRampdvdt( m_currentModel->m_ramp.m_falling );
 }
 else
 {
 Report( _( "Invalid ramp data" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 }
 return status;
}
 
 
bool IbisParser::readModelSpec()
{
 bool status = true;
 
 m_continue = IBIS_PARSER_CONTINUE::MODEL_SPEC;
 
 // TODO
 // readTypMinMaxValueSubparam( std::string( "Vmeas" ), m_currentModel->... )
 // ...
 
 return status;
}
 
 
bool IbisParser::parseModel( std::string& aKeyword )
{
 bool status = false;
 
 if( compareIbisWord( aKeyword.c_str(), "Voltage_Range" ) )
 status = readTypMinMaxValue( m_currentModel->m_voltageRange );
 else if( compareIbisWord( aKeyword.c_str(), "Temperature_Range" ) )
 status = readTypMinMaxValue( m_currentModel->m_temperatureRange );
 else if( compareIbisWord( aKeyword.c_str(), "GND_Clamp" ) )
 status = readIVtableEntry( m_currentModel->m_GNDClamp );
 else if( compareIbisWord( aKeyword.c_str(), "POWER_Clamp" ) )
 status = readIVtableEntry( m_currentModel->m_POWERClamp );
 else if( compareIbisWord( aKeyword.c_str(), "Pulldown" ) )
 status = readIVtableEntry( m_currentModel->m_pulldown );
 else if( compareIbisWord( aKeyword.c_str(), "Pullup" ) )
 status = readIVtableEntry( m_currentModel->m_pullup );
 else if( compareIbisWord( aKeyword.c_str(), "Rising_Waveform" ) )
 status = readWaveform( nullptr, IBIS_WAVEFORM_TYPE::RISING );
 else if( compareIbisWord( aKeyword.c_str(), "Falling_Waveform" ) )
 status = readWaveform( nullptr, IBIS_WAVEFORM_TYPE::FALLING );
 else if( compareIbisWord( aKeyword.c_str(), "Ramp" ) )
 status = readRamp();
 else if( compareIbisWord( aKeyword.c_str(), "Model_Spec" ) )
 status = readModelSpec();
 else if( compareIbisWord( aKeyword.c_str(), "Pullup_Reference" ) )
 status = readTypMinMaxValue( m_currentModel->m_pullupReference );
 else if( compareIbisWord( aKeyword.c_str(), "Pulldown_Reference" ) )
 status = readTypMinMaxValue( m_currentModel->m_pulldownReference );
 else if( compareIbisWord( aKeyword.c_str(), "POWER_Clamp_Reference" ) )
 status = readTypMinMaxValue( m_currentModel->m_POWERClampReference );
 else if( compareIbisWord( aKeyword.c_str(), "GND_Clamp_Reference" ) )
 status = readTypMinMaxValue( m_currentModel->m_GNDClampReference );
 else if( compareIbisWord( aKeyword.c_str(), "Rac" ) )
 status = readTypMinMaxValue( m_currentModel->m_Rac );
 else if( compareIbisWord( aKeyword.c_str(), "Cac" ) )
 status = readTypMinMaxValue( m_currentModel->m_Cac );
 else if( compareIbisWord( aKeyword.c_str(), "Rpower" ) )
 status = readTypMinMaxValue( m_currentModel->m_Rpower );
 else if( compareIbisWord( aKeyword.c_str(), "Rgnd" ) )
 status = readTypMinMaxValue( m_currentModel->m_Rgnd );
 else
 {
 status = changeContext( aKeyword );
 }
 return status;
}
 
bool IbisParser::readPackageModelPins()
{
 m_continue = IBIS_PARSER_CONTINUE::PACKAGEMODEL_PINS;
 std::string str;
 
 if( readWord( str ) )
 m_currentPackageModel->m_pins.push_back( str );
 
 return true;
}
 
 
bool IbisParser::readMatrixBanded( std::string aKeyword, IBIS_MATRIX_BANDED& aDest )
{
 bool status = true;
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 
 if( compareIbisWord( aKeyword.c_str(), "Bandwidth" ) )
 {
 if( m_currentMatrix->m_type == IBIS_MATRIX_TYPE::BANDED )
 {
 status &= readInt( aDest.m_bandwidth );
 if( status )
 {
 aDest.m_data.resize( aDest.m_bandwidth * aDest.m_dim );
 }
 }
 else
 {
 status = false;
 Report( _( "Cannot specify a bandwidth for that kind of matrix" ), RPT_SEVERITY_ERROR );
 }
 }
 if( !compareIbisWord( aKeyword.c_str(), "Dummy" ) )
 {
 int i;
 for( i = 0; i < aDest.m_bandwidth; i++ )
 {
 if( i + m_currentMatrixRowIndex >= aDest.m_bandwidth )
 {
 Report( "Too much data for this matrix row", RPT_SEVERITY_ERROR );
 status = false;
 break;
 }
 
 int index = i + m_currentMatrixRow * aDest.m_bandwidth;
 
 if( !readDouble( aDest.m_data[index] ) )
 {
 Report( _( "Invalid row in matrix" ), RPT_SEVERITY_ERROR );
 status = false;
 break;
 }
 }
 m_currentMatrixRowIndex = i;
 }
 
 return status;
}
 
 
bool IbisParser::readMatrixFull( std::string aKeyword, IBIS_MATRIX_FULL& aDest )
{
 bool status = true;
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 
 if( !compareIbisWord( aKeyword.c_str(), "Dummy" ) )
 {
 std::vector<std::string> values;
 
 status &= readTableLine( values );
 int i;
 for( i = 0; i < (int)values.size(); i++ )
 {
 int index = i + m_currentMatrixRow * aDest.m_dim + m_currentMatrixRow;
 // + final m_currentMatrixRow because we don't fill the lower triangle.
 
 if( i >= ( aDest.m_dim - m_currentMatrixRow - m_currentMatrixRowIndex ) )
 {
 Report( _( "Too much data for this matrix row." ), RPT_SEVERITY_ERROR );
 status = false;
 break;
 }
 
 if( index >= aDest.m_dim * aDest.m_dim )
 {
 status = false;
 Report( _( "Too much data for this matrix." ), RPT_SEVERITY_ERROR );
 break;
 }
 if( !parseDouble( aDest.m_data[index], values.at( i ), true ) )
 {
 Report( _( "Can't read a matrix element" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 else
 {
 }
 }
 m_currentMatrixRowIndex = i;
 }
 return status;
}
 
 
bool IbisParser::readMatrixSparse( std::string aKeyword, IBIS_MATRIX_SPARSE& aDest )
{
 bool status = true;
 
 if( !compareIbisWord( aKeyword.c_str(), "Dummy" ) )
 {
 int subindex;
 double value;
 
 if( readInt( subindex ) )
 {
 if( readDouble( value ) )
 {
 #if 0
 // Currently not used
 int index = subindex + m_currentMatrixRow * aDest.m_dim + m_currentMatrixRow;
 #endif
 }
 else
 {
 Report( _( "Can't read a matrix element" ), RPT_SEVERITY_ERROR );
 }
 }
 else
 {
 Report( _( "Can't read a matrix index" ), RPT_SEVERITY_ERROR );
 }
 }
 return status;
}
 
bool IbisParser::readMatrix( std::shared_ptr<IBIS_MATRIX> aDest )
{
 bool status = true;
 std::string str;
 
 bool init = false;
 
 if( aDest != nullptr )
 {
 if( aDest->m_type != IBIS_MATRIX_TYPE::BANDED && aDest->m_type != IBIS_MATRIX_TYPE::FULL
 && aDest->m_type != IBIS_MATRIX_TYPE::SPARSE )
 {
 init = false;
 }
 else
 {
 init = true;
 }
 }
 else
 {
 Report( "Matrix pointer is null." );
 status = false;
 }
 
 if( m_continue != IBIS_PARSER_CONTINUE::MATRIX && status )
 {
 if( !init )
 {
 if( readWord( str ) )
 {
 IBIS_MATRIX* matrix;
 
 if( compareIbisWord( str.c_str(), "Banded_matrix" ) )
 {
 matrix = static_cast<IBIS_MATRIX*>( new IBIS_MATRIX_BANDED( m_reporter ) );
 aDest = static_cast<std::shared_ptr<IBIS_MATRIX>>( matrix );
 m_currentMatrix = aDest;
 m_currentMatrix->m_type = IBIS_MATRIX_TYPE::BANDED;
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 }
 else if( compareIbisWord( str.c_str(), "Full_matrix" ) )
 {
 matrix = static_cast<IBIS_MATRIX*>( new IBIS_MATRIX_FULL( m_reporter ) );
 aDest = static_cast<std::shared_ptr<IBIS_MATRIX>>( matrix );
 m_currentMatrix = aDest;
 matrix->m_dim = m_currentPackageModel->m_numberOfPins;
 m_currentMatrix->m_type = IBIS_MATRIX_TYPE::FULL;
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 }
 else if( compareIbisWord( str.c_str(), "Sparse_matrix" ) )
 {
 matrix = static_cast<IBIS_MATRIX*>( new IBIS_MATRIX_SPARSE( m_reporter ) );
 aDest = static_cast<std::shared_ptr<IBIS_MATRIX>>( matrix );
 m_currentMatrix = aDest;
 m_currentMatrix->m_data.resize( matrix->m_dim * matrix->m_dim );
 m_currentMatrix->m_type = IBIS_MATRIX_TYPE::SPARSE;
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 }
 else
 {
 status = false;
 Report( _( "Unknown matrix type" ), RPT_SEVERITY_ERROR );
 Report( str, RPT_SEVERITY_INFO );
 m_currentMatrix->m_dim = m_currentPackageModel->m_numberOfPins;
 }
 }
 else
 {
 status = false;
 Report( _( "Missing matrix type" ), RPT_SEVERITY_ERROR );
 }
 }
 else
 {
 status = false;
 Report( _( " Matrix is already init. But m_continue was not set ( internal error )" ) );
 }
 }
 else
 {
 if( aDest != nullptr )
 {
 // If m_continue is set, ( and no keyword ) then it is a row
 switch( aDest->m_type )
 {
 case IBIS_MATRIX_TYPE::BANDED:
 readMatrixBanded( std::string( "Dummy" ),
 *static_cast<IBIS_MATRIX_BANDED*>( aDest.get() ) );
 break;
 case IBIS_MATRIX_TYPE::FULL:
 readMatrixFull( std::string( "Dummy" ),
 *static_cast<IBIS_MATRIX_FULL*>( aDest.get() ) );
 break;
 case IBIS_MATRIX_TYPE::SPARSE:
 readMatrixSparse( std::string( "Dummy" ),
 *static_cast<IBIS_MATRIX_SPARSE*>( aDest.get() ) );
 break;
 case IBIS_MATRIX_TYPE::UNDEFINED:
 default:
 {
 status = false;
 Report( _( "Tried to read a row from an undefined matrix" ) );
 }
 }
 }
 else
 {
 Report( _( "matrix pointer is null" ) );
 }
 }
 return status;
}
 
bool IbisParser::parsePackageModelModelData( std::string& aKeyword )
{
 bool status = true;
 
 if( compareIbisWord( aKeyword.c_str(), "Resistance_Matrix" ) )
 {
 IBIS_MATRIX dest( m_reporter ), source( m_reporter );
 status &= readMatrix( m_currentPackageModel->m_resistanceMatrix );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Capacitance_Matrix" ) )
 {
 status &= readMatrix( m_currentPackageModel->m_capacitanceMatrix );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Inductance_Matrix" ) )
 {
 status &= readMatrix( m_currentPackageModel->m_inductanceMatrix );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Bandwidth" ) )
 {
 status &= readMatrixBanded( aKeyword,
 *static_cast<IBIS_MATRIX_BANDED*>( m_currentMatrix.get() ) );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Row" ) )
 {
 status &= readInt( m_currentMatrixRow );
 m_currentMatrixRow--; // The matrix starts at 0
 m_currentMatrixRowIndex = 0; // The matrix starts at 0*/
 m_continue = IBIS_PARSER_CONTINUE::MATRIX;
 }
 else if( compareIbisWord( aKeyword.c_str(), "End_Model_Data" ) )
 {
 m_context = IBIS_PARSER_CONTEXT::PACKAGEMODEL;
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 }
 else
 {
 if( !changeContext( aKeyword ) )
 {
 status = false;
 }
 }
 return status;
}
 
bool IbisParser::parsePackageModel( std::string& aKeyword )
{
 bool status = true;
 
 if( compareIbisWord( aKeyword.c_str(), "Manufacturer" ) )
 status &= storeString( m_currentPackageModel->m_manufacturer, false );
 else if( compareIbisWord( aKeyword.c_str(), "OEM" ) )
 status &= storeString( m_currentPackageModel->m_OEM, false );
 else if( compareIbisWord( aKeyword.c_str(), "Description" ) )
 status &= storeString( m_currentPackageModel->m_description, false );
 else if( compareIbisWord( aKeyword.c_str(), "Number_of_Pins" ) )
 status &= readInt( m_currentPackageModel->m_numberOfPins );
 else if( compareIbisWord( aKeyword.c_str(), "Pin_Numbers" ) )
 status &= readPackageModelPins();
 else if( compareIbisWord( aKeyword.c_str(), "Model_Data" ) )
 {
 m_context = IBIS_PARSER_CONTEXT::PACKAGEMODEL_MODELDATA;
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 }
 else
 {
 if( !changeContext( aKeyword ) )
 {
 status = false;
 }
 }
 return status;
}
 
bool IbisParser::readModelSelector()
{
 bool status = true;
 
 IbisModelSelectorEntry model;
 
 if( !readWord( model.m_modelName ) )
 return false;
 
 status &= readString( model.m_modelDescription );
 m_currentModelSelector->m_models.push_back( model );
 
 return status;
}
 
bool IbisParser::readNumericSubparam( std::string aSubparam, double& aDest )
{
 std::string paramName;
 bool status = true;
 
 if( aSubparam.size() >= (size_t)m_lineLength )
 {
 // Continuing would result in an overflow
 return false;
 }
 
 int old_index = m_lineIndex;
 m_lineIndex = 0;
 
 
 for( size_t i = 0; i < aSubparam.size(); i++ )
 {
 paramName += m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 if( strcmp( paramName.c_str(), aSubparam.c_str() ) )
 {
 m_lineIndex = old_index;
 return false;
 }
 
 skipWhitespaces();
 
 status &= m_buffer[m_lineOffset + m_lineIndex++] == '=';
 
 if( status )
 {
 skipWhitespaces();
 status &= readDouble( aDest );
 }
 
 if( !status )
 {
 m_lineIndex = old_index;
 }
 
 return status;
}
 
 
bool IbisParser::readTypMinMaxValue( TypMinMaxValue& aDest )
{
 bool status = true;
 
 skipWhitespaces();
 
 std::string strValue;
 
 if( !readDouble( aDest.value[IBIS_CORNER::TYP] ) )
 {
 Report( _( "Typ-Min-Max Values requires at least Typ." ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 readDouble( aDest.value[IBIS_CORNER::MIN] );
 readDouble( aDest.value[IBIS_CORNER::MAX] );
 
 return status;
}
 
bool IbisParser::readTypMinMaxValueSubparam( std::string aSubparam, TypMinMaxValue& aDest )
{
 std::string paramName;
 bool status = true;
 
 m_lineIndex = 0; // rewind
 
 if( aSubparam.size() < (size_t)m_lineLength )
 {
 for( size_t i = 0; i < aSubparam.size(); i++ )
 {
 paramName += m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 if( !strcmp( paramName.c_str(), aSubparam.c_str() ) )
 {
 readTypMinMaxValue( aDest );
 }
 else
 {
 status = false;
 }
 }
 else
 {
 status = false;
 }
 
 return status;
}
 
bool IbisParser::readModel()
{
 bool status = true;
 
 std::string subparam;
 if( readWord( subparam ) )
 {
 switch( m_continue )
 {
 case IBIS_PARSER_CONTINUE::MODEL:
 
 if( !strcmp( subparam.substr( 0, 10 ).c_str(), "Model_type" ) )
 {
 if( readWord( subparam ) )
 {
 if( compareIbisWord( subparam.c_str(), "Input" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::INPUT_STD;
 else if( compareIbisWord( subparam.c_str(), "Output" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::OUTPUT;
 else if( compareIbisWord( subparam.c_str(), "I/O" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::IO;
 else if( compareIbisWord( subparam.c_str(), "3-state" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::THREE_STATE;
 else if( compareIbisWord( subparam.c_str(), "Open_drain" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::OPEN_DRAIN;
 else if( compareIbisWord( subparam.c_str(), "I/O_Open_drain" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::IO_OPEN_DRAIN;
 else if( compareIbisWord( subparam.c_str(), "Open_sink" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::OPEN_SINK;
 else if( compareIbisWord( subparam.c_str(), "I/O_open_sink" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::IO_OPEN_SINK;
 else if( compareIbisWord( subparam.c_str(), "Open_source" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::OPEN_SOURCE;
 else if( compareIbisWord( subparam.c_str(), "I/O_open_source" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::IO_OPEN_SOURCE;
 else if( compareIbisWord( subparam.c_str(), "Input_ECL" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::INPUT_ECL;
 else if( compareIbisWord( subparam.c_str(), "Output_ECL" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::OUTPUT_ECL;
 else if( compareIbisWord( subparam.c_str(), "I/O_ECL" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::IO_ECL;
 else if( compareIbisWord( subparam.c_str(), "3-state_ECL" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::THREE_STATE_ECL;
 else if( compareIbisWord( subparam.c_str(), "Terminator" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::TERMINATOR;
 else if( compareIbisWord( subparam.c_str(), "Series" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::SERIES;
 else if( compareIbisWord( subparam.c_str(), "Series_switch" ) )
 m_currentModel->m_type = IBIS_MODEL_TYPE::SERIES_SWITCH;
 else
 {
 std::stringstream message;
 message << _( "Unknown Model_type " ) << subparam;
 Report( message.str(), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else
 {
 Report( _( "Internal Error while reading model_type" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else if( !strcmp( subparam.substr( 0, 7 ).c_str(), "Enable" ) )
 {
 if( readWord( subparam ) )
 {
 if( !strcmp( subparam.c_str(), "Active-High" ) )
 m_currentModel->m_enable = IBIS_MODEL_ENABLE::ACTIVE_HIGH;
 else if( !strcmp( subparam.c_str(), "Active-Low" ) )
 m_currentModel->m_enable = IBIS_MODEL_ENABLE::ACTIVE_LOW;
 else
 {
 std::stringstream message;
 message << _( "Unknown Enable: " ) << subparam;
 Report( message.str(), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else
 {
 Report( _( "Internal Error while reading Enable" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else if( subparam.substr( 0, 9 ) == "Polarity" )
 {
 if( readWord( subparam ) )
 {
 if( subparam == "Inverting" )
 m_currentModel->m_enable = IBIS_MODEL_ENABLE::ACTIVE_HIGH;
 else if( subparam == "Non-Inverting" )
 m_currentModel->m_enable = IBIS_MODEL_ENABLE::ACTIVE_LOW;
 else
 {
 std::stringstream message;
 message << _( "Unknown polarity " ) << subparam;
 Report( message.str(), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else
 {
 Report( _( "Internal Error while reading Enable" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 else if( readNumericSubparam( std::string( "Vinl" ), m_currentModel->m_vinl ) )
 ;
 else if( readNumericSubparam( std::string( "Vinh" ), m_currentModel->m_vinh ) )
 ;
 else if( readNumericSubparam( std::string( "Vref" ), m_currentModel->m_vref ) )
 ;
 else if( readNumericSubparam( std::string( "Rref" ), m_currentModel->m_rref ) )
 ;
 else if( readNumericSubparam( std::string( "Cref" ), m_currentModel->m_cref ) )
 ;
 else if( readNumericSubparam( std::string( "Vmeas" ), m_currentModel->m_vmeas ) )
 ;
 else if( readTypMinMaxValueSubparam( std::string( "C_comp" ),
 m_currentModel->m_C_comp ) )
 ;
 else
 {
 status = false;
 }
 
 m_continue = IBIS_PARSER_CONTINUE::MODEL;
 
 break;
 
 default:
 status = false;
 Report( _( "Continued reading a model that did not begin. ( internal error )" ),
 RPT_SEVERITY_ERROR );
 }
 }
 
 return status;
}
 
 
bool IbisParser::parseHeader( std::string& aKeyword )
{
 bool status = true;
 
 if( compareIbisWord( aKeyword.c_str(), "IBIS_Ver" ) )
 {
 status &= readDouble( m_ibisFile.m_header.m_ibisVersion );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Comment_char" ) )
 {
 status &= changeCommentChar();
 }
 else if( compareIbisWord( aKeyword.c_str(), "File_Name" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_fileName, false );
 }
 else if( compareIbisWord( aKeyword.c_str(), "File_Rev" ) )
 {
 status &= readDouble( m_ibisFile.m_header.m_fileRevision );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Source" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_source, true );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Notes" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_notes, true );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Disclaimer" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_disclaimer, true );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Copyright" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_copyright, true );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Date" ) )
 {
 status &= storeString( m_ibisFile.m_header.m_date, false );
 }
 else
 {
 if( !changeContext( aKeyword ) )
 {
 status = false;
 }
 }
 return status;
}
 
 
bool IbisParser::parseComponent( std::string& aKeyword )
{
 bool status = true;
 if( compareIbisWord( aKeyword.c_str(), "Manufacturer" ) )
 {
 status &= storeString( m_currentComponent->m_manufacturer, true );
 }
 else if( compareIbisWord( aKeyword.c_str(), "Package" ) )
 {
 status &= readPackage();
 }
 else if( compareIbisWord( aKeyword.c_str(), "Pin" ) )
 {
 status &= readPin();
 }
 else if( compareIbisWord( aKeyword.c_str(), "Pin_Mapping" ) )
 {
 status &= readPinMapping();
 }
 else if( compareIbisWord( aKeyword.c_str(), "Diff_Pin" ) )
 {
 status &= readDiffPin();
 }
 /*
 // Not supported yet
 else if( aKeyword == "Die_Supply_Pads" )
 {
 status &= ReadDieSupplyPads();
 }*/
 else if( compareIbisWord( aKeyword.c_str(), "Package_Model" ) )
 {
 status &= storeString( m_currentComponent->m_packageModel, true );
 }
 else
 {
 if( !changeContext( aKeyword ) )
 {
 status = false;
 }
 }
 return status;
}
 
bool IbisParser::readTableLine( std::vector<std::string>& aDest )
{
 aDest.clear();
 
 while( m_lineIndex < m_lineLength )
 {
 std::string str;
 
 while( ( !isspace( m_buffer[m_lineOffset + m_lineIndex] ) )
 && ( m_lineIndex < m_lineLength ) )
 {
 str += m_buffer[m_lineOffset + m_lineIndex++];
 }
 
 if( str.size() > 0 )
 {
 aDest.push_back( str );
 }
 while( isspace( m_buffer[m_lineOffset + m_lineIndex] ) && ( m_lineIndex < m_lineLength ) )
 {
 m_lineIndex++;
 }
 }
 return true;
}
 
bool IbisParser::readPackage()
{
 bool status = true;
 
 std::vector<std::string> fields;
 
 TypMinMaxValue* R = &( m_currentComponent->m_package.m_Rpkg );
 TypMinMaxValue* L = &( m_currentComponent->m_package.m_Lpkg );
 TypMinMaxValue* C = &( m_currentComponent->m_package.m_Cpkg );
 
 readTableLine( fields );
 
 int extraArg = ( m_continue == IBIS_PARSER_CONTINUE::NONE ) ? 1 : 0;
 
 if( (int)fields.size() == ( 4 + extraArg ) )
 {
 TypMinMaxValue* cValue;
 
 if( fields.at( 0 ) == "R_pkg" )
 cValue = R;
 else if( fields.at( 0 ) == "L_pkg" )
 cValue = L;
 else if( fields.at( 0 ) == "C_pkg" )
 cValue = C;
 else
 {
 Report( "Invalid field in [Package]" );
 return false;
 }
 status &= parseDouble( cValue->value[IBIS_CORNER::TYP], fields.at( 1 ), true );
 // Min / max values are optional, so don't update the status
 parseDouble( cValue->value[IBIS_CORNER::MIN], fields.at( 2 ), true );
 parseDouble( cValue->value[IBIS_CORNER::MAX], fields.at( 3 ), true );
 }
 else
 {
 if( fields.size() != 0 )
 {
 Report( _( "A [Package] line requires exactly 4 elements." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 m_continue = IBIS_PARSER_CONTINUE::COMPONENT_PACKAGE;
 
 return status;
}
 
 
bool IbisParser::readPin()
{
 bool status = true;
 
 std::vector<std::string> fields;
 
 m_lineIndex = 0;
 status &= readTableLine( fields );
 
 IbisComponentPin pin( m_reporter );
 
 if( ( fields.size() == 3 ) )
 {
 if( m_continue == IBIS_PARSER_CONTINUE::COMPONENT_PIN ) // No info on first line
 {
 pin.m_pinName = fields.at( 0 );
 pin.m_signalName = fields.at( 1 );
 pin.m_modelName = fields.at( 2 );
 pin.m_Rcol = m_currentComponent->m_pins.back().m_Rcol;
 pin.m_Lcol = m_currentComponent->m_pins.back().m_Lcol;
 pin.m_Ccol = m_currentComponent->m_pins.back().m_Ccol;
 
 m_currentComponent->m_pins.push_back( pin );
 }
 else
 {
 pin.m_dummy = true;
 }
 }
 else
 {
 if( m_continue == IBIS_PARSER_CONTINUE::COMPONENT_PIN ) // Not on the first line
 {
 pin.m_pinName = fields.at( 0 );
 pin.m_signalName = fields.at( 1 );
 pin.m_modelName = fields.at( 2 );
 
 pin.m_Rcol = m_currentComponent->m_pins.back().m_Rcol;
 pin.m_Lcol = m_currentComponent->m_pins.back().m_Lcol;
 pin.m_Ccol = m_currentComponent->m_pins.back().m_Ccol;
 
 if( pin.m_Rcol == 0 || pin.m_Lcol == 0 || pin.m_Ccol == 0 )
 {
 Report( _( "Invalid pin entry: 6 values from a table with only 3." ),
 RPT_SEVERITY_ERROR );
 status = false; // Did we just try to go from a 3 column table to a 6 ?
 }
 else
 {
 if( !parseDouble( pin.m_Rpin, fields.at( pin.m_Rcol ), true )
 || !parseDouble( pin.m_Lpin, fields.at( pin.m_Lcol ), true )
 || !parseDouble( pin.m_Cpin, fields.at( pin.m_Ccol ), true ) )
 {
 Report( _( "Can't read a R, L or C value for a pin." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 }
 else
 {
 for( int i = 3; i < 6; i++ )
 {
 if( fields.at( i ) == "R_pin" )
 {
 pin.m_Rcol = i;
 }
 else if( fields.at( i ) == "L_pin" )
 {
 pin.m_Lcol = i;
 }
 else if( fields.at( i ) == "C_pin" )
 {
 pin.m_Ccol = i;
 }
 else
 {
 Report( _( "Invalid field name in [Pin]" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 }
 
 if( pin.m_Rcol == 0 || pin.m_Lcol == 0 || pin.m_Ccol == 0 )
 {
 Report( _( "Missing argument in [Pin]" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 pin.m_dummy = true;
 }
 }
 
 m_currentComponent->m_pins.push_back( pin );
 m_continue = IBIS_PARSER_CONTINUE::COMPONENT_PIN;
 
 
 return status;
}
 
 
bool IbisParser::readPinMapping()
{
 bool status = true;
 
 std::vector<std::string> fields;
 
 status &= readTableLine( fields );
 
 IbisComponentPinMapping pinMapping( m_reporter );
 
 if( m_continue == IBIS_PARSER_CONTINUE::NONE ) // No info on first line
 {
 m_continue = IBIS_PARSER_CONTINUE::COMPONENT_PINMAPPING;
 }
 else
 {
 if( fields.size() != 0 )
 {
 if( fields.size() > 6 || fields.size() < 3 )
 {
 Report( _( "Wrong number of columns for pin mapping." ), RPT_SEVERITY_ERROR );
 status = false;
 }
 else
 {
 pinMapping.m_pinName = fields.at( 0 );
 pinMapping.m_PDref = fields.at( 1 );
 pinMapping.m_PUref = fields.at( 2 );
 
 if( fields.size() > 3 )
 pinMapping.m_GNDClampRef = fields.at( 3 );
 
 if( fields.size() > 4 )
 pinMapping.m_POWERClampRef = fields.at( 4 );
 
 if( fields.size() > 5 )
 pinMapping.m_extRef = fields.at( 5 );
 }
 m_currentComponent->m_pinMappings.push_back( pinMapping );
 }
 }
 return status;
}
 
 
bool IbisParser::readDiffPin()
{
 bool status = true;
 
 m_lineIndex = 0; // rewind
 IbisDiffPinEntry entry( m_reporter );
 
 if( m_continue == IBIS_PARSER_CONTINUE::NONE ) // No info on first line
 {
 m_continue = IBIS_PARSER_CONTINUE::COMPONENT_DIFFPIN;
 }
 else
 {
 if( !readWord( entry.pinA ) )
 {
 Report( _( "Incorrect diff pin name" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( !readWord( entry.pinB ) )
 {
 Report( _( "Incorrect inv_pin name" ), RPT_SEVERITY_ERROR );
 status = false;
 }
 if( status )
 {
 m_currentComponent->m_diffPin.m_entries.push_back( entry );
 }
 }
 return status;
}
 
 
bool IbisParser::readIVtableEntry( IVtable& aDest )
{
 bool status = true;
 
 skipWhitespaces();
 
 IVtableEntry entry( m_reporter );
 
 if( m_lineIndex < m_lineLength )
 {
 std::string str;
 
 status &= readDouble( entry.V );
 
 if( status && readTypMinMaxValue( entry.I ) )
 {
 aDest.m_entries.push_back( entry );
 }
 }
 
 m_continue = IBIS_PARSER_CONTINUE::IV_TABLE;
 m_currentIVtable = &aDest;
 
 
 return status;
}
 
bool IbisParser::readVTtableEntry( VTtable& aDest )
{
 bool status = true;
 skipWhitespaces();
 
 VTtableEntry entry( m_reporter );
 
 if( m_lineIndex < m_lineLength )
 {
 std::string str;
 status &= readDouble( entry.t );
 status &= readTypMinMaxValue( entry.V );
 }
 
 m_continue = IBIS_PARSER_CONTINUE::IV_TABLE;
 m_currentVTtable = &aDest;
 
 if( status )
 {
 aDest.m_entries.push_back( entry );
 }
 
 return status;
}
 
bool IbisParser::readWaveform( IbisWaveform* aDest, IBIS_WAVEFORM_TYPE aType )
{
 bool status = true;
 
 
 IbisWaveform* wf;
 
 if( m_continue != IBIS_PARSER_CONTINUE::WAVEFORM )
 {
 wf = new IbisWaveform( m_reporter );
 wf->m_type = aType;
 
 switch( aType )
 {
 case IBIS_WAVEFORM_TYPE::FALLING: m_currentModel->m_fallingWaveforms.push_back( wf ); break;
 case IBIS_WAVEFORM_TYPE::RISING: m_currentModel->m_risingWaveforms.push_back( wf ); break;
 default: Report( _( "Unknown waveform type" ), RPT_SEVERITY_ERROR ); status = false;
 }
 }
 else
 {
 if( aDest != nullptr )
 {
 wf = aDest;
 }
 else
 {
 Report( _( "Internal error detected, a waveform should exist" ), RPT_SEVERITY_ERROR );
 return false;
 }
 }
 
 
 if( status & !isLineEmptyFromCursor() )
 {
 // readNumericSubparam() returns true if it could read the subparameter and store it
 // Testing all subparameters
 if( readNumericSubparam( std::string( "R_fixture" ), wf->m_R_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "L_fixture" ), wf->m_L_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "C_fixture" ), wf->m_C_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "V_fixture" ), wf->m_V_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "V_fixture_min" ), wf->m_V_fixture_min ) )
 ;
 else if( readNumericSubparam( std::string( "V_fixture_max" ), wf->m_V_fixture_max ) )
 ;
 else if( readNumericSubparam( std::string( "R_dut" ), wf->m_R_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "L_dut" ), wf->m_L_fixture ) )
 ;
 else if( readNumericSubparam( std::string( "C_dut" ), wf->m_C_fixture ) )
 ;
 // The line is not a subparameter, then let's try to read a VT table entry
 else if( !readVTtableEntry( m_currentWaveform->m_table ) )
 {
 status = false;
 }
 }
 m_currentWaveform = wf;
 m_continue = IBIS_PARSER_CONTINUE::WAVEFORM;
 return status;
}
 
bool IbisParser::onNewLine()
{
 bool status = true;
 char c;
 std::string keyword = getKeyword();
 
 if( keyword.size() > 0 ) // New keyword
 {
 
 if( m_continue != IBIS_PARSER_CONTINUE::NONE )
 {
 m_continue = IBIS_PARSER_CONTINUE::NONE;
 }
 switch( m_context )
 {
 case IBIS_PARSER_CONTEXT::HEADER: status &= parseHeader( keyword ); break;
 case IBIS_PARSER_CONTEXT::COMPONENT: status &= parseComponent( keyword ); break;
 case IBIS_PARSER_CONTEXT::MODELSELECTOR: status &= parseModelSelector( keyword ); break;
 case IBIS_PARSER_CONTEXT::MODEL: status &= parseModel( keyword ); break;
 case IBIS_PARSER_CONTEXT::PACKAGEMODEL: status &= parsePackageModel( keyword ); break;
 case IBIS_PARSER_CONTEXT::PACKAGEMODEL_MODELDATA:
 status &= parsePackageModelModelData( keyword );
 break;
 default:
 {
 status = false;
 Report( _( "Internal error: Bad parser context." ), RPT_SEVERITY_ERROR );
 }
 }
 }
 else
 {
 skipWhitespaces();
 if( m_lineIndex == m_lineLength )
 {
 // That was an empty line
 return true;
 }
 
 // No new keyword ? Then it is the continuation of the previous one !
 switch( m_continue )
 {
 case IBIS_PARSER_CONTINUE::STRING:
 skipWhitespaces();
 *m_continuingString += '\n';
 status &= readString( *m_continuingString );
 break;
 case IBIS_PARSER_CONTINUE::COMPONENT_PACKAGE: status &= readPackage(); break;
 case IBIS_PARSER_CONTINUE::COMPONENT_PIN: status &= readPin(); break;
 case IBIS_PARSER_CONTINUE::COMPONENT_PINMAPPING: status &= readPinMapping(); break;
 case IBIS_PARSER_CONTINUE::COMPONENT_DIFFPIN: status &= readDiffPin(); break;
 case IBIS_PARSER_CONTINUE::MODELSELECTOR: status &= readModelSelector(); break;
 case IBIS_PARSER_CONTINUE::MODEL: status &= readModel(); break;
 case IBIS_PARSER_CONTINUE::IV_TABLE: status &= readIVtableEntry( *m_currentIVtable ); break;
 case IBIS_PARSER_CONTINUE::VT_TABLE: status &= readVTtableEntry( *m_currentVTtable ); break;
 case IBIS_PARSER_CONTINUE::WAVEFORM:
 status &= readWaveform( m_currentWaveform, m_currentWaveform->m_type );
 break;
 case IBIS_PARSER_CONTINUE::RAMP: status &= readRamp(); break;
 case IBIS_PARSER_CONTINUE::MODEL_SPEC: status &= readModelSpec(); break;
 case IBIS_PARSER_CONTINUE::PACKAGEMODEL_PINS: status &= readPackageModelPins(); break;
 case IBIS_PARSER_CONTINUE::MATRIX: status &= readMatrix( m_currentMatrix ); break;
 case IBIS_PARSER_CONTINUE::NONE:
 default:
 Report( _( "Missing keyword." ), RPT_SEVERITY_ERROR );
 return false;
 break;
 }
 }
 c = m_buffer[m_lineOffset + m_lineIndex];
 
 while( ( c != '\n' ) && ( c != 0 ) ) // Go to the end of line
 {
 c = m_buffer[m_lineOffset + m_lineIndex++];
 }
 return status;
}