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 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 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>
#include <io/kicad/kicad_io_utils.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;        
};
 
 
#define OUTPUTFMTBUFZ    500        

class KICOMMON_API OUTPUTFORMATTER
{
protected:
    OUTPUTFORMATTER( int aReserve = OUTPUTFMTBUFZ, char aQuoteChar = '"' ) :
            m_buffer( aReserve, '\0' )
    {
        quoteChar[0] = aQuoteChar;
        quoteChar[1] = '\0';
    }

    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_N __attribute__( ( format( printf, 3, 4 ) ) )
#define PRINTF_FUNC __attribute__( ( format( printf, 2, 3 ) ) )
#else
#define PRINTF_FUNC_N     // nothing
#define PRINTF_FUNC       // nothing
#endif
 
public:
    virtual ~OUTPUTFORMATTER() {}

    int PRINTF_FUNC_N Print( int nestLevel, const char* fmt, ... );

    int PRINTF_FUNC Print( 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;
    }
 
    std::string& MutableString()
    {
        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,
            KICAD_FORMAT::FORMAT_MODE aFormatMode = KICAD_FORMAT::FORMAT_MODE::NORMAL,
            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;
    KICAD_FORMAT::FORMAT_MODE m_mode;
};
 
 
#endif // RICHIO_H_