richio.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2007-2010 SoftPLC Corporation, Dick Hollenbeck <[email protected]>
 * Copyright (C) 2016-2020 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 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef RICHIO_H_
#define RICHIO_H_
 
// This file defines 3 classes useful for working with DSN text files and is named
// "richio" after its author, Richard Hollenbeck, aka Dick Hollenbeck.
 
 
#include <vector>
#include <core/utf8.h>
 
// I really did not want to be dependent on wxWidgets in richio
// but the errorText needs to be wide char so wxString rules.
#include <cstdio>
#include <wx/string.h>
#include <wx/stream.h>
 
#include <ki_exception.h>
#include <kicommon.h>
 
KICOMMON_API int
#if defined(__GNUG__)
 __attribute__ ((format (printf, 2, 3)))
#endif
 StrPrintf( std::string* aResult, const char* aFormat, ... );
 
 
KICOMMON_API std::string
#if defined(__GNUG__)
 __attribute__ ((format (printf, 1, 2)))
#endif
 StrPrintf( const char* format, ... );
 
 
KICOMMON_API wxString SafeReadFile( const wxString& aFilePath, const wxString& aReadType );
 
 
#define LINE_READER_LINE_DEFAULT_MAX 1000000
#define LINE_READER_LINE_INITIAL_SIZE 5000
 
class KICOMMON_API LINE_READER
{
public:
 
 LINE_READER( unsigned aMaxLineLength = LINE_READER_LINE_DEFAULT_MAX );
 
 virtual ~LINE_READER();
 
 virtual char* ReadLine() = 0;
 
 virtual const wxString& GetSource() const
 {
 return m_source;
 }
 
 char* Line() const
 {
 return m_line;
 }
 
 operator char* () const
 {
 return Line();
 }
 
 virtual unsigned LineNumber() const
 {
 return m_lineNum;
 }
 
 unsigned Length() const
 {
 return m_length;
 }
 
protected:
 void expandCapacity( unsigned aNewsize );
 
 unsigned m_length; 
 unsigned m_lineNum;
 
 char* m_line; 
 unsigned m_capacity; 
 
 unsigned m_maxLineLength; 
 
 wxString m_source; 
};
 
 
class KICOMMON_API FILE_LINE_READER : public LINE_READER
{
public:
 FILE_LINE_READER( const wxString& aFileName, unsigned aStartingLineNumber = 0,
 unsigned aMaxLineLength = LINE_READER_LINE_DEFAULT_MAX );
 
 FILE_LINE_READER( FILE* aFile, const wxString& aFileName, bool doOwn = true,
 unsigned aStartingLineNumber = 0,
 unsigned aMaxLineLength = LINE_READER_LINE_DEFAULT_MAX );
 
 ~FILE_LINE_READER();
 
 char* ReadLine() override;
 
 void Rewind()
 {
 rewind( m_fp );
 m_lineNum = 0;
 }
 
 long int FileLength();
 long int CurPos();
 
protected:
 bool m_iOwn; 
 FILE* m_fp; 
};
 
 
class KICOMMON_API STRING_LINE_READER : public LINE_READER
{
protected:
 std::string m_lines;
 size_t m_ndx;
 
public:
 
 STRING_LINE_READER( const std::string& aString, const wxString& aSource );
 
 STRING_LINE_READER( const STRING_LINE_READER& aStartingPoint );
 
 char* ReadLine() override;
};
 
 
class KICOMMON_API INPUTSTREAM_LINE_READER : public LINE_READER
{
public:
 INPUTSTREAM_LINE_READER( wxInputStream* aStream, const wxString& aSource );
 
 char* ReadLine() override;
 
protected:
 wxInputStream* m_stream; //< The input stream to read. No ownership of this pointer.
};
 
 
#define OUTPUTFMTBUFZ 500 
 
class KICOMMON_API OUTPUTFORMATTER
{
protected:
 OUTPUTFORMATTER( int aReserve = OUTPUTFMTBUFZ, char aQuoteChar = '"' ) :
 m_buffer( aReserve, '\0' )
 {
 quoteChar[0] = aQuoteChar;
 quoteChar[1] = '\0';
 }
 
 virtual ~OUTPUTFORMATTER() {}
 
 static const char* GetQuoteChar( const char* wrapee, const char* quote_char );
 
 virtual void write( const char* aOutBuf, int aCount ) = 0;
 
#if defined(__GNUG__) // The GNU C++ compiler defines this
 
 // When used on a C++ function, we must account for the "this" pointer,
 // so increase the STRING-INDEX and FIRST-TO_CHECK by one.
 // See http://docs.freebsd.org/info/gcc/gcc.info.Function_Attributes.html
 // Then to get format checking during the compile, compile with -Wall or -Wformat
#define PRINTF_FUNC __attribute__( ( format( printf, 3, 4 ) ) )
#else
#define PRINTF_FUNC // nothing
#endif
 
public:
 int PRINTF_FUNC Print( int nestLevel, const char* fmt, ... );
 
 virtual const char* GetQuoteChar( const char* wrapee ) const;
 
 virtual std::string Quotes( const std::string& aWrapee ) const;
 
 std::string Quotew( const wxString& aWrapee ) const;
 
 virtual bool Finish() { return true; }
 
private:
 std::vector<char> m_buffer;
 char quoteChar[2];
 
 int sprint( const char* fmt, ... );
 int vprint( const char* fmt, va_list ap );
 
};
 
 
class KICOMMON_API STRING_FORMATTER : public OUTPUTFORMATTER
{
public:
 STRING_FORMATTER( int aReserve = OUTPUTFMTBUFZ, char aQuoteChar = '"' ) :
 OUTPUTFORMATTER( aReserve, aQuoteChar )
 {
 }
 
 void Clear()
 {
 m_mystring.clear();
 }
 
 void StripUseless();
 
 const std::string& GetString()
 {
 return m_mystring;
 }
 
protected:
 void write( const char* aOutBuf, int aCount ) override;
 
private:
 std::string m_mystring;
};
 
 
class KICOMMON_API FILE_OUTPUTFORMATTER : public OUTPUTFORMATTER
{
public:
 
 FILE_OUTPUTFORMATTER( const wxString& aFileName, const wxChar* aMode = wxT( "wt" ),
 char aQuoteChar = '"' );
 
 ~FILE_OUTPUTFORMATTER();
 
protected:
 void write( const char* aOutBuf, int aCount ) override;
 
 FILE* m_fp; 
 wxString m_filename;
};
 
 
class KICOMMON_API PRETTIFIED_FILE_OUTPUTFORMATTER : public OUTPUTFORMATTER
{
public:
 PRETTIFIED_FILE_OUTPUTFORMATTER( const wxString& aFileName, const wxChar* aMode = wxT( "wt" ),
 char aQuoteChar = '"' );
 
 ~PRETTIFIED_FILE_OUTPUTFORMATTER();
 
 bool Finish() override;
 
protected:
 void write( const char* aOutBuf, int aCount ) override;
 
private:
 FILE* m_fp;
 std::string m_buf;
};
 
 
#endif // RICHIO_H_