StdioStream.h

Go to the documentation of this file.

 
#ifndef StdioStream_h
#define StdioStream_h
#include "ios.h"
#include <limits.h>
//------------------------------------------------------------------------------
const uint8_t STREAM_BUF_SIZE = 64;
const uint8_t UNGETC_BUF_SIZE = 2;
//------------------------------------------------------------------------------
// Get rid of any macros defined in <stdio.h>.
#include <stdio.h>
#undef clearerr
#undef fclose
#undef feof
#undef ferror
#undef fflush
#undef fgetc
#undef fgetpos
#undef fgets
#undef fopen
#undef fprintf
#undef fputc
#undef fputs
#undef fread
#undef freopen
#undef fscanf
#undef fseek
#undef fsetpos
#undef ftell
#undef fwrite
#undef getc
#undef getchar
#undef gets
#undef perror
//#undef printf  // NOLINT
#undef putc
#undef putchar
#undef puts
#undef remove
#undef rename
#undef rewind
#undef scanf
#undef setbuf
#undef setvbuf
//#undef sprintf  // NOLINT
#undef sscanf
#undef tmpfile
#undef tmpnam
#undef ungetc
#undef vfprintf
#undef vprintf
#undef vsprintf
 
// make sure needed macros are defined
#ifndef EOF
#define EOF (-1)
#endif // EOF
#ifndef NULL
#define NULL 0
#endif // NULL
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif // SEEK_CUR
#ifndef SEEK_END
#define SEEK_END 2
#endif // SEEK_END
#ifndef SEEK_SET
#define SEEK_SET 0
#endif // SEEK_SET
//------------------------------------------------------------------------------
class StdioStream : private StreamBaseFile
{
  public:
    StdioStream()
    {
    }
    //----------------------------------------------------------------------------
    void clearerr()
    {
        m_status &= ~(S_ERR | S_EOF);
    }
    //----------------------------------------------------------------------------
    int fclose();
    //----------------------------------------------------------------------------
    int feof()
    {
        return (m_status & S_EOF) != 0;
    }
    //----------------------------------------------------------------------------
    int ferror()
    {
        return (m_status & S_ERR) != 0;
    }
    //----------------------------------------------------------------------------
    int fflush();
    //----------------------------------------------------------------------------
    int fgetc()
    {
        return m_r-- == 0 ? fillGet() : *m_p++;
    }
    //----------------------------------------------------------------------------
    char *fgets(char *str, size_t num, size_t *len = 0);
    //----------------------------------------------------------------------------
    bool fopen(const char *path, const char *mode);
    //----------------------------------------------------------------------------
    int fputc(int c)
    {
        return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
    }
    //----------------------------------------------------------------------------
    int fputs(const char *str);
    //----------------------------------------------------------------------------
    size_t fread(void *ptr, size_t size, size_t count);
    //----------------------------------------------------------------------------
    int fseek(int32_t offset, int origin);
    //----------------------------------------------------------------------------
    int32_t ftell();
    //----------------------------------------------------------------------------
    size_t fwrite(const void *ptr, size_t size, size_t count);
    //----------------------------------------------------------------------------
    inline __attribute__((always_inline)) int getc()
    {
        return m_r-- == 0 ? fillGet() : *m_p++;
    }
    //----------------------------------------------------------------------------
    inline __attribute__((always_inline)) int putc(int c)
    {
        return m_w-- == 0 ? flushPut(c) : *m_p++ = c;
    }
    //----------------------------------------------------------------------------
    inline __attribute__((always_inline)) int putCRLF()
    {
        if (m_w < 2)
        {
            if (!flushBuf())
            {
                return -1;
            }
        }
        *m_p++ = '\r';
        *m_p++ = '\n';
        m_w -= 2;
        return 2;
    }
    //----------------------------------------------------------------------------
    size_t print(char c)
    {
        return putc(c) < 0 ? 0 : 1;
    }
    //----------------------------------------------------------------------------
    size_t print(const char *str)
    {
        int n = fputs(str);
        return n < 0 ? 0 : n;
    }
    //----------------------------------------------------------------------------
#if (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
    size_t print(const __FlashStringHelper *str);
#endif // (defined(ARDUINO) && ENABLE_ARDUINO_FEATURES) || defined(DOXYGEN)
    //----------------------------------------------------------------------------
    size_t print(double val, uint8_t prec = 2)
    {
        return print(static_cast<float>(val), prec);
    }
    //----------------------------------------------------------------------------
    size_t print(float val, uint8_t prec = 2)
    {
        int n = printDec(val, prec);
        return n > 0 ? n : 0;
    }
    //----------------------------------------------------------------------------
    template <typename T> size_t print(T val)
    {
        int n = printDec(val);
        return n > 0 ? n : 0;
    }
    //----------------------------------------------------------------------------
    size_t println()
    {
        return putCRLF() > 0 ? 2 : 0;
    }
    //----------------------------------------------------------------------------
    size_t println(double val, uint8_t prec = 2)
    {
        return println(static_cast<float>(val), prec);
    }
    //----------------------------------------------------------------------------
    size_t println(float val, uint8_t prec = 2)
    {
        int n = printDec(val, prec);
        return n > 0 && putCRLF() > 0 ? n + 2 : 0;
    }
    //----------------------------------------------------------------------------
    template <typename T> size_t println(T val)
    {
        int n = print(val);
        return putCRLF() > 0 ? n + 2 : 0;
    }
    //----------------------------------------------------------------------------
    int printDec(char n)
    {
        if (CHAR_MIN == 0)
        {
            return printDec((unsigned char)n);
        }
        else
        {
            return printDec((signed char)n);
        }
    }
    //----------------------------------------------------------------------------
    int printDec(signed char n);
    //----------------------------------------------------------------------------
    int printDec(unsigned char n)
    {
        return printDec((uint16_t)n);
    }
    //----------------------------------------------------------------------------
    int printDec(int16_t n);
    //----------------------------------------------------------------------------
    int printDec(uint16_t n);
    //----------------------------------------------------------------------------
    int printDec(int32_t n);
    //----------------------------------------------------------------------------
    int printDec(uint32_t n);
    //----------------------------------------------------------------------------
    int printDec(double value, uint8_t prec)
    {
        return printDec(static_cast<float>(value), prec);
    }
    //----------------------------------------------------------------------------
    int printDec(float value, uint8_t prec);
    //----------------------------------------------------------------------------
    int printField(double value, char term, uint8_t prec = 2)
    {
        return printField(static_cast<float>(value), term, prec) > 0;
    }
    //----------------------------------------------------------------------------
    int printField(float value, char term, uint8_t prec = 2)
    {
        int rtn = printDec(value, prec);
        return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
    }
    //----------------------------------------------------------------------------
    template <typename T> int printField(T value, char term)
    {
        int rtn = printDec(value);
        return rtn < 0 || putc(term) < 0 ? -1 : rtn + 1;
    }
    //----------------------------------------------------------------------------
    int printHex(uint32_t n);
    //----------------------------------------------------------------------------
    int printHexln(uint32_t n)
    {
        int rtn = printHex(n);
        return rtn < 0 || putCRLF() != 2 ? -1 : rtn + 2;
    }
    //----------------------------------------------------------------------------
    bool rewind();
    //----------------------------------------------------------------------------
    int ungetc(int c);
    //============================================================================
  private:
    bool fillBuf();
    int fillGet();
    bool flushBuf();
    int flushPut(uint8_t c);
    char *fmtSpace(uint8_t len);
    int write(const void *buf, size_t count);
    //----------------------------------------------------------------------------
    // S_SRD and S_WR are never simultaneously asserted
    static const uint8_t S_SRD = 0x01; // OK to read
    static const uint8_t S_SWR = 0x02; // OK to write
    static const uint8_t S_SRW = 0x04; // open for reading & writing
    static const uint8_t S_EOF = 0x10; // found EOF
    static const uint8_t S_ERR = 0x20; // found error
    //----------------------------------------------------------------------------
    uint8_t m_buf[STREAM_BUF_SIZE];
    uint8_t m_status = 0;
    uint8_t *m_p = m_buf;
    uint8_t m_r = 0;
    uint8_t m_w;
};
//------------------------------------------------------------------------------
#endif // StdioStream_h